Possible Duplicate:
What is the most convenient way to read definitions of in-memory symbols when we don’t have the source files?

I would like to look at the code that implements FillingTransform. Does Mathematica provide any way to do this?

  • 2
    $\begingroup$ I think in general the answer must be no. Mathematica is not open source software. Sometimes the help documentation will reveal more, but with FillingTransform this seems not to be the case. $\endgroup$ Jan 3, 2013 at 13:45
  • 1
    $\begingroup$ In general, any function that has attribute ReadProtected is mainly implemented in Mathematica code and you can access its source by removing the attribute (as in Oleks' answer). There are of course those readprotected functions that simply call another function that is fully concealed. There is little hope that someone is able to reverse-engineer these functions just by observing their behaviour. $\endgroup$ Jan 3, 2013 at 17:07

1 Answer 1


In general, @Jacob Akkerboom is correct: one cannot usually view the source code for arbitrary Mathematica functions. In this particular case, however, we find an exception.

By doing:

FillingTransform (* trigger auto-load *)
ClearAttributes[FillingTransform, ReadProtected]


we observe a call to iFillingTransform (i.e. the implementation of FillingTransform; this naming convention is commonly encountered among recently added functions). Thereafter,


reveals a number of checks on the arguments and setup for a call to oFillingTransform. If one does


then the complete implementation becomes visible. Although I won't reproduce that here for obvious reasons, the basic idea is a combination of GeodesicErosion and GeodesicDilation with some image arithmetic to mask off each hole in turn.

  • 1
    $\begingroup$ Hiho hiho... been spelunking again? $\endgroup$
    – Yves Klett
    Jan 3, 2013 at 14:33
  • $\begingroup$ There are more functions which might be analysed this way. Could you find them all or most of them ? $\endgroup$
    – Artes
    Jan 3, 2013 at 18:39
  • 1
    $\begingroup$ @Artes Have you looked at Simon's answer in the linked duplicate? I find it so useful that it's in my inits $\endgroup$
    – rm -rf
    Jan 3, 2013 at 20:27
  • $\begingroup$ @R. M. Thanks for your advice. Indeed, Simon's answer is very handy. Nevertheless, what could I do if I'd like to collect all those functions for which Spelunk yielded interesting information ? Mapping it like here Spelunk /@ ToExpression@Names["System*"]` is not a good idea. $\endgroup$
    – Artes
    Jan 3, 2013 at 20:47
  • 1
    $\begingroup$ @Artes Well, that would require a definition of "interesting", right? :) Barring any contextual information that might be of interest to the programmer, how do you programmatically gauge what's worth looking into in the entire system? Do you go by the number of down-values defined or the character length of the definition or something else? My experience has been that I only find useful internal stuff when I'm in need of something and go spelunking. Most of the time, even simple code looks boring under the hood, because of all the checks for invalid user input, which adds to the bloat. $\endgroup$
    – rm -rf
    Jan 3, 2013 at 21:45

Not the answer you're looking for? Browse other questions tagged or ask your own question.