Which Mathematica files may be deleted to save space

Question

After installation Mathematica 8 for Linux takes more than 3GB in the /usr/local/Wolfram/ directory. I suspect that not all of it is relevant if I want to do some occasional computations. Are there subdirectories which can be deleted safely to save some space?

Answer 1

1. You can save a lot of space in the Documentation directory by using Delete All Output on all the larger ones and by using disk compression. For example, the v7 documentation Notebook for ContourPlot is 27.7MB, but after deleting output it is only 192k, and after NTFS compression only 72k. Doing this will require evaluating the documentation page before you can see the examples, but it will easily save 500MB for version 7; probably more in later versions.

   You can modify this answer as per your needs to programmatically delete all the output cells from the notebooks in the Documentation directory.

2. As Oleksandr suggests you can delete the SystemFiles/Java/<$SystemID> folder(s), which contain copies of the JVM, if you have Java installed separately, saving about 190MB of space. (Or, following point #3, about half that.)

3. Initial testing indicates that core functionality is retained after deleting binaries for the other system type (32 or 64 bit) from SystemFiles\Kernel\Binaries, SystemFiles\FrontEnd\Binaries and SystemFiles\Converters\Binaries saving about 88MB for version 7.

Under Windows you can use WinDirStat to easily visualize the space allocation within a drive or directory tree. That page recommends KDirStat for Linux and Disk Inventory X for OS X.

Answer 2

Half of it appears to be in ../Documentation , you could delete that and look everything up on the Wolfram site on the web

Answer 3

Since Windows doesn't display directory sizes for me I wrote a tiny utility to let Mathematica display them in a collapsible tree form (code at the bottom).

I opened up some candidates for deletion, but you should try them first by moving the specific directories out of the MMA directory structure. As Image_doctor said, the documentation is a good sized candidate, as well as the 32/64 bit versions of the binaries suggested by Szabolcs. Further candidates can be found in the Links directory (but don't touch the MathLink directory; many of the others are probably safe, but no guarantee).

directoryTree[startDir_] :=
 Module[{names, dirs, files, sizeFiles, sizeDirs, sons},
  SetDirectory[startDir];
  names = FileNames[];
  dirs = Select[names, (FileType[#] == Directory &)];
  files = Complement[names, dirs];
  sizeFiles = Total[FileByteCount /@ files];
  sons = If[Length[dirs] > 0, directoryTree /@ dirs, {}];
  ResetDirectory[];
  sizeDirs = If[Length[sons] > 0, Total[sons[[All, 2 ;; 3]], 2], 0];
  {startDir, sizeFiles, sizeDirs, sons}
]

dirTreeView[{}] := ""
dirTreeView[dT_] := 
  OpenerView[
    {
     Row[{First[dT], " (", Length[dT[[4]]], ", ", Total@dT[[2 ;; 3]], ")"}], 
     Column[dirTreeView /@ dT[[4]], Frame -> All]
    }
  ]

dirTreeView@directoryTree[$InstallationDirectory]

Answer 4

In general, you can delete directories that correspond to settings of $SystemID other than what you use. For example, I could delete the contents of

SystemFiles/Kernel/SystemResources/MacOSX-x86/

since Mathematica on my machine has "MacOSX-x86-64" as its $SystemID, so it will use the files in

SystemFiles/Kernel/SystemResources/MacOSX-x86-64/

---

Additionally, as an extreme measure, on OS X MathKernel is a universal binary:

> file MathKernel 
MathKernel: Mach-O universal binary with 2 architectures
MathKernel (for architecture i386): Mach-O executable i386
MathKernel (for architecture x86_64): Mach-O 64-bit executable x86_64

and you can use lipo(-suction, I presume) from a command line to thin it down:

lipo -extract i386 -output MathKernel32 MathKernel
lipo -extract x86_64 -output MathKernel64 MathKernel

and then rename the appropriate bitted kernel to MathKernel. On my system, this would save about 70 MB.

Answer 5

As a supplement to the other answers, here's a code sample that deletes output from the documentation notebooks. Put this in an .nb file, save it, and run it - I've tested using Mathematica 10.4. You will need to ensure the documentation notebooks are writable by the user account under which you're running Mathematica while the script runs.

There is a fairly significant catch: in my tests, this crashes the front end. Repeatedly. Every ~200 files, on average. To help work around this, every 20 files the code prints out the number of files it's processed so far, and then saves itself. That way, when it crashes, you can open up the notebook, look at the last printed output, and adjust the first argument of stripDocs to match so you can pick up where you left off. I realize this is far from ideal, but in the absence of any specific code in the other answers, I figured it would be useful.

directoryTreeRecursion[startDir_] := Block[
  {names, dirs, files, sizeFiles, sizeDirs, children},
  Sow[startDir, "directory"];
  SetDirectory[startDir];
  names = FileNameJoin[{startDir, #}] & /@ FileNames[];
  dirs = Select[names, (FileType[#] == Directory &)];
  files = Complement[names, dirs];
  Sow[#, "file"] & /@ files;
  children = 
   If[Length[dirs] > 0, directoryTreeRecursion /@ dirs, {}];
  ResetDirectory[];
  ]
directoryTree[startDir_] := Reap[directoryTreeRecursion[startDir]][[2]]

stripOutput[filename_, mode_: "Notebook"] := Block[{},
  Switch[mode,
   "FrontEnd",
   (*advise against using this, it will close the current notebook*)
   FrontEndExecute[{
     FrontEndToken["Open", filename],
     FrontEndToken["DeleteGeneratedCells"],
     FrontEndToken["Save"],
     FrontEndToken["Close"]
     }],
   "Notebook",
   Block[{nb},
    nb = NotebookOpen[filename, Visible -> False];
    NotebookDelete[Cells[nb, CellStyle -> "Output"]];
    NotebookSave[nb];
    NotebookClose[nb];
    ],
   _,
   Message[stripOutput::mode, mode];
   ]
  ]
stripOutput::mode = "`1` is not a valid mode; only \"Kernel\" or \"FrontEnd\" is recognized."; 

doclist = directoryTree@FileNameJoin[{$InstallationDirectory, "Documentation"}];
docnblist = Select[doclist[[2]], StringEndsQ[#, ".nb"] &];

timeFormat[seconds_] := Block[
  {h = Floor[seconds/3600], m = Mod[Floor[seconds/60], 60], 
   s = Mod[seconds, 60]},
  TemplateApply[
   If[h > 0, "`1`:`2`:`3`",
    If[m > 0, "`2`:`3`",
     "0:`3`"
     ]
    ],
   {h, If[m < 10, "0" ~~ ToString[m], m], 
    If[s < 10, "0" ~~ ToString[s], s]}
   ]
  ]

stripDocs[min_, max_] := Block[
  {
   numberTemplate = 
    StringTemplate["Currently processing `1` of `2`"],
   timeProgressTemplate = 
    StringTemplate["`1` elapsed, `2` estimated remaining"],
   startTime,
   fn
  },
  startTime = AbsoluteTime[];
  Monitor[
   For[i = min, i <= max, i += 1,
    fn = docnblist[[i]];
    stripOutput[fn];
    If[
     Mod[i, 20] == 0,
     PrintTemporary[i];
     NotebookSave[];
     Pause[1]
     ]
    ],
   Column[{
     ProgressIndicator[Dynamic[i], {min, max + 1}, 
      ImageSize -> {500, 20}],
     numberTemplate[i - min + 1, max - min + 1],
     With[{t = AbsoluteTime[] - startTime}, 
      timeProgressTemplate[timeFormat@Ceiling[t], 
       timeFormat@Ceiling[(max + 1 - i)/(i - min + 1) t]]],
     docnblist[[i]]
     }]
   ]
  ]

stripDocs[1, Length[docnblist]]

Parts of this code were adapted from Sjoerd's answer and, on another question, Szabolcs' answer, István's answer, and bobknight's answer