How To Build A Bin File For Mac

Next:, Previous:, Up: R for Mac OS X FAQ Frequently Asked Questions on R for Mac OS X Version 3.5.0 2018-04-23, R.app 1.71 Stefano M. Iacus Simon Urbanek Rob J. Goedman Brian Ripley.:.:.:.:.:.:.:.:.:.: — The Detailed Node Listing — Introduction.:.:.: R.app.:.:.:.:.:.:.: The R Console.:.:.:.:.: General Features.:.:.:.:.:.:.:.:.:.:.: The Menus.:.:.:.:.:.:.: Preferences.: Startup.:.:.:.: How to install packages.:.:.:.: R and external applications.:.:.: Quartz device.:.:.: Additional resources.:.: Miscellaneous questions.:.:.:.:.:.:.:.:.:.:.:.:.:.:.

Next:, Previous:, Up: 1 Introduction This document contains a user guide to the R.APP version of R, and information on using R on OS X which supplements the main R manuals. As from R 3.0.0 most of the information has been moved to those manuals, the latest versions of which can be found at. In this document R refers to the core, command-line-based R system while R.APP refers to the GUI-based Mac OS application that controls the underlying R. This ‘R for Mac OS X FAQ’ is rather incomplete at the moment and requires contributions from users. Anything specific to the R language can be found in the main R-FAQ (see ). Please send any requests/questions you would like answers to the mailing list (after subscribing) as well as comments on this FAQ. The last section of this document contains the most frequently asked questions that don’t fit strictly into any of the categories above – it is usually a good idea to always look into that section if your issue doesn’t fit any of the above or was not answered in one of the specific sections.

Always read this FAQ before asking for help on R-SIG-Mac! Previous:, Up: 1.3 How can R for Mac OS X be obtained and installed? R is available on CRAN in the form of an Installer package containing the R framework and the R.APP GUI.

The package is usually named R.pkg with an optional version number. The installation is done by double-clicking on the Installer package. The Installer will guide you through the necessary steps. Note that it will require password or login of an account with administrator privileges. The installation can be customized, but the default is suitable for most users. Snapshots of the R-patched and R-devel flavours are available at, packaged in the same way.

Further details, including uninstallation and building R from the sources, are in the ‘R Installation and Administration Manual’. Next:, Previous:, Up: 2.3.3 The current and startup working directories If not otherwise specified in the Preferences (see ), or if the specified path is no longer available, then the default working directory at startup is the user home. The working directory can be changed using the setwd R command or using the Misc menu item Change working directory. Finally it is possible to use a specific directory for a single R session by dragging a folder onto the R.APP icon. If R.APP is not running, this will cause R.APP to be started in the directory corresponding to the folder dragged. The same can be achieved on the command line – for example open -a R.

Causes R.APP to be started using the current directory as the startup working directory. This feature is useful if you want different startup procedures defined by the.Rprofile; you can edit a.Rprofile (containing you personal initialization R commands) in a particular directory and use the Preferences (or any other method mentioned above) to change the startup directory. Next time you launch R.app the.Rprofile is read and executed by R at startup. This is the equivalent on Unix (or the command line) to launch R from different directories.

Next:, Previous:, Up: 2.4.2 Editor undo and line numbers The editor supports undo/redo operations on an appropriate level of granularity (used to be all or nothing). The editor has an optional facility to show line numbers.

These help with locating error messages. The editor also responds to the ’Go to Line’ Edit menu function. The associated Preference Pane allows enabling/disabling of the line numbers, as well as setting line number gutter width (to fit larger line numbers) and text margin width. Next:, Previous:, Up: 2.4.5 Editor syntax coloring The editor supports syntax-highlighting for R code. It is possible to change the syntax highlighting colors using the Syntax Color Preference Pane (see below).

Starting with R.APP version 1.17 lazy syntax highlighting is used, which means that changes influencing the entire file (such as typing a single or double quote) no longer apply to the entire file, but only a few lines. This temporary state is usually recovered by closing the quote, but in some rare instances it may persist until a change is made to the first line of the offending quote.

However, lazy highlighting brings huge speedup when editing large files. Next:, Previous:, Up: 2.4.6 Editor (internal and external) By default, the editor used is incorporated into R.APP, the Mac OS X GUI for R. It is a relatively simple multi-document editor that supports the features listed above. Additionally, two powerful commands are available to source the file being edited in its entirety ( Command-E) or to source the current selection to R ( Command-Return). Using R’s edit function, allows editing of R objects or files while R is kept waiting for the edit session to finish.

It is possible to ’redirect’ all R requests to an external editor, which runs outside R.APP. In that case, it is not possible to keep R waiting if edit is used. Using AppleScript it is easy to implement Command-E and Command-Return like functionality. Next:, Previous:, Up: 2.4.8 Drag & drop Drag and drop of a directory on the R.APP icon while R.APP is not running will start R.APP and set the working directory. By default.RData and the history file (default name.Rapp.history) are fetched from this working directory.

If a file is dropped on the R.APP icon while R.APP is not running, R.APP is started, the file is either restored (if it is a saved workspace), sourced into R.APP or opened in the selected editor. Whether the file is opened or sourced is specified by a Preference setting in the StartUp Preference Pane. Note: At this point opening a file in the editor before R.APP is finished loading will crash R.APP. While R.APP is running, drag & drop of a directory updates the working directory.

Drag & drop of a file sources or opens the file in the selected editor. Double clicking on files bound to ('Open With.' ) R, if R.APP is not running, R.APP is started and the file is sourced or opened in editor. If R.APP is running, the file is opened in the editor. Next:, Previous:, Up: 2.4.10 History R.APP uses history files that are (superset) compatible with history files created by R.

Multiline support remains available from inside R.APP. Multiline is particularly useful when using the Command- Return feature while editing an R script. Import and export allows storing and importing history from files visible in the Mac OS Finder.

Build A Mac Computer

Multiline is preserved. This can be set through the StartUp Preference Panel.

Default number of kept history entries is 250. A variety of history entry cleanup modes is possible. At a minimum it is suggested to select 'Cleanup history entries'.

It’s optional to select removal of duplicate entries and strip comments. Note: Command-line R stores history in a file usually called.Rhistory. It is suggested to use a different name for the R.APP history file, and the default is.Rapp.history.

Note that the functions loadhistory, savehistory and hence history are not currently supported in R.APP. Previous:, Up: 2.4.11 Authentication and.libPaths The official CRAN binaries come pre-packaged in such a way that administrator have sufficient privileges to update R and install packages system-wide. However, the default Unix build requires root-authentication for package installation and other administrative tasks. As it is not feasible to run the GUI as root, we provide the possibility to authenticate system commands issued from the GUI. The authentication requires an administrator login and causes all subsequent system commands to be executed as root. Use with care!

In order to allow non-administrators to maintain their own set of packages, R.APP optionally adds /Library/R/x.y/library to the.libPaths (see start-up preferences, x.y denotes the R version without patch level). It is possible to use the Package Installer to install packages either globally (admin users only) or for the current user only. (This is the same mechanism for personal library directories described in the main R documentation, but with a location specific to CRAN-like builds of R on OS X.) Note that user-local packages are only used when the corresponding preference option is enabled. The default for admin users is to use system-wide directories, for non-admin users the personal library directory will be used. Next:, Previous:, Up: 2.5.5 Workspace Menu Here you find self explanatory menu items for manage your workspace in R. You can either load and save the workspace also by specifying file name.

All of these are interfaces to the load and save R commands. The only relevant item, which is specific to this GUI, is Browse workspace which invokes the browseEnv function in R. This will open a window with a summary description of the objects in your workspace. Recursive objects (like lists, data.frame etc) can be expanded (one level only though). Next:, Previous:, Up: 2.5.6 Packages Menu Using this menu you can have access to the list of packages and data-sets installed on your system and to the ones on CRAN or on the Bioconductor site.

With the first two menus you can load and detach packages and data-set from the workspace. Let’s start with the Package Manager. This opens a window with several columns displayed.

For each package on your system you can see a check box, the current status of the package (loaded/not loaded), its name and the package description text. You use the check box to select/de-select the packages you want.

On window closure, the checked packaged will be loaded and the unchecked ones (if loaded) will the detached (not completely as on Mac OS X you cannot unload completely dynamic libraries). The same applies to the Dataset Manager menu but for data-sets.

You can than get or update packages CRAN either in binary or source format. Daily build of CRAN packages are available for Mac OS X. If you don’t know how to build R itself from source, you’ll probably be unable to build packages from source on your own. In this case, you should always choose for the binary option. These binary packages work (for sure!) for the release version of R for Mac OS X you find on CRAN even though it is not excluded that they will work for other prebuilt versions of R.

When you attempt to install packages from CRAN, R first tries to get a connection to the Internet to download the list of available packages. Than a window will open similar to the one in the package manager with the only difference that for each package there is also the information concerning the version of the package installed on your system (if any) and the version of the prebuilt package available on CRAN. When you close the window, the select packages will be downloaded. The same strategy applies to the Bioconductor menu item, with some more options typical of the Bioconductor way of managing packages.

For some reason it could happen that you have the package you want to install (either in binary or source form) on one of your local disks, or even a directory containing a package source. You can use the last menu to do the task of installing the package. Having a package in a directory form usually applies to people that are developing packages themselves. Note that packages which do not contain C, C, Fortran code which needs to be compiled can be compiled from their sources with no additional tools. For more information on this topic see also.

Previous:, Up: 2.6.1 Startup The Drag & drop section defines drag & drop behaviour during R start-up. Options are to open file in an editor or to source file. Default is to source the file. The Default Library Paths section enables, on next start-up of R, to add a directory, e.g. /R/Library, to the library search/install path.

The initial working directory section can be used to enforce the initial working directory. If no directory is specified, this directory is used as the default. The Change button allows to select a new directory.

The Always apply selection will enforce the specified intial start-up directory. The history section controls reading of the history file on startup. If selected, R will read history file on start-up. The R history file field is used to read and store history from/to. This field can be edited to allow selecting files starting with a period (e.g.Rapp.history).

If you want the same history file regardless of your selected working directory, specify a fixed path (e.g. The Default button will reset the history file name to its default value. The History handling area allows setting of the max number of entries to be kept in history, to remove duplicate entries, to cleanup history entries (this is very useful to remove blank lines when submitting multiple lines using Command-Return) and the strip comments before the entry is added to the history. Next:, Previous:, Up: 2.6.1.1 Editor Preferences If Built-in editor is selected, allows enable/disable of syntax coloring, brace highlighting and the showing of line numbers. If External editor is selected, allows specifying which external editor. That editor will be used for all editing functions.

It runs as a separate application. Using an external editor means that R will never wait while editing (e.g.

Edit(A) will return immediately and open A in the external editor. Command-E and Command-Return like functionality would need to be implemented by other means, i.e. The external editor can be any application (e.g. SubEthaEdit, TextWrangler, BBEdit, Smultron, etc) or can be activated through a shell script (e.g. See or smultron, both give better control on how to start the editor). Previous:, Up: 2.7 R.app Bugs On Unix systems a bug report can be generated using the function bug.report.

Alternatively the bug report can be submitted to the Web page at. Before you file a bug report, please try to reproduce it using both R.APP and the console version of R (if applicable). If the bug if R.APP-specific, please report the bug to the mailing list instead.

Please do NOT forget to mention the exact R.APP version and include the output of sessionInfo. In any circumstances, in case of a crash, please report the crash.log for the R.bin and/or R.app application. You can get this crash.log using the Console.app located inside /Applications/Utilities (select ‘1’ in the crash menu in the R console at the time of the crash (if you see that menu) to generate a crash report). Next:, Previous:, Up: 3.2 Installation of packages R for Mac OS X recognizes packages in two forms: binary packages and source packages. Binary packages are R packages in ready-to-use form, such that no additional tools are necessary for their use. Binary packages are specific for a given R version and OS. CRAN and Bioconductor repositories offer R packages in binary form for the last released R version.

Unlike on other Unix systems, R for Mac OS X installs binary packages by default, i.e. Install.packages will look for binary repositories unless instructed otherwise. Source packages are general in that they can be used on any platform and OS supported by R, but they need to be processed and/or compiled before they can be used.

Additional tools may be necessary for that, see see for details. For most users binary packages are sufficient (if available and current). On Mac OS X packages can be installed in three ways:. Using Package Manager in the R.APP GUI (recommended for most Mac users). Using install.packages command in R.

Using R CMD INSTALL command in the shell (aka Terminal) The latter two methods are common to all Unix systems and as such described in the general R documentation. In the following we will concentrate on using the Package Installer. If you decide to install packages you should use the Packages & Data menu of the GUI, in particular the sub-item Package Installer. Select the repository, package type (binary or source) and press Get List. This will connect to the repository through the Internet and a list all packages available for installation. The list tells you if a package is already installed on your system, the version of the package available on CRAN and the version of the same package if already installed.

You can use the search field to narrow the list of package to those matching your search criteria. Additionally you can use the search list menu to list only packages that are already installed on your system which is useful for comparing versions of available and installed packages.

Finally, you can filter down to packages that have been installed by a previous R version as to allow a simple upgrade. Select any package you want to install and press the Install button.

You can follow the progress of the installation in the R Console. Once the required packages are installed, the list is re-loaded to reflect the versions of newly installed packages. If you want to update all packages to the latest version, select the repository to use for the packages and press Update All. R will automatically determine the list of packages that can be updated and present you with a selection of packages to update. You can also download any other package from the Internet yourself and decide to install it from source. In such case select one of the local entries in the top left list and press the Install button (which is now enabled). Packages can also be installed from other repositories by selecting Other Repository source.

Enter the repository URL in the adjacent field. Note that currently the Package Installer assumes that custom repositories maintain proper hierarchy for both source and binary packages the same way CRAN does when using Other Repository. If your custom repository is flat, select Other Directory URL in the installation type list. Next:, Previous:, Up: 3.3 Installation of source packages Source packages which do not contain compiled code can (with rare exceptions) be installed with no additional tools. Packages with compiled code (or some with Unix scripts) need the tools used to build R itself discussed in the ‘R Installation and Administation Manual’, and these will need to be in the ‘ PATH’ as seen from R.APP or command-line R. For R.APP you may need to add e.g. /usr/local/bin and it is usually most convenient to use command-line R.

If using a CRAN binary install of R the compilers may not be in the same place or have the same names as on the CRAN build machine. Look at file /Library/Frameworks/R.framework/Resources/etc/Makeconf, which will contain lines like.

Previous:, Up: 3.4 Where are the packages I’ve installed? The main library of packages is the one located inside the R.framework (in /Library/Frameworks/R.framework/Resources/library). This library contains the packages (base and recommended ones) distributed along with R.

Only administrators are allowed to install packages in this system-wide directory. Note that this directory is R-version-specific. Optionally users can install personal packages in their /Library/R/x.y/library directory where x.y denotes the R version without the patch level (such as 3.0) – see the startup preferences in R.APP. The Package Installer performs installation to either place depending on the installation target setting. The default for an admin users is to install packages system-wide, whereas the default for regular users is their personal library tree. If you use install.packages R function instead of the Package Installer, the regular Unix behavior applies (see help pages for details). For default setup this means that the packages are installed according to the startup preference setting.

You can check the current defaults by issuing. Cmd where command string have to be in quotes. Actually, the output of the command is not sent back to the application that is calling R but to the R Console directly. There are some issues. The first is that if R is still not running, it will take a while (depending on how fast your machine is) to startup. In the meanwhile the script sends commands without waiting and it could happen that some commands are missed by R, i.e. They arrive before R is ready to receive applescript commands.

The second issue, is that it could be that the applescript calls a bad version of R. This could happen if you have an old version of R (for example the old Carbon R) installed on your System. As an example, we report here a small script that asks R to source a file using a file dialog.

Previous:, Up: 4.3 Finder actions Dragging a file on the R icon, causes R to source this file via the source R command or, if the file is an R image data file RDX1 or RDX2 (normally files with extension.rda or.RData), the data is loaded in the workspace and every object with the same name in the workspace is overwritten without notice. Loading a data file is equivalent to the R command load. At the moment there is no control over the file types, i.e. Dragging wrong files (i.e.

Files that are not R scripts or image data) simply gives an error. It is up to the user to do the right thing. If R is not yet running this action causes R to startup. Next:, Previous:, Up: 6 Tcl/Tk issues Each binary distribution of R available through CRAN is built to use the X11 implementation of Tcl/Tk. Of course a X windows server has to be started first: this should happen automatically on OS X, provided it has been installed (it needs a separate install on Mountain Lion and later). The first time things are done in the X server there can be a long delay whilst a font cache is constructed; starting the server can take several seconds. Mac OS X 10.9 and higher no longer include X11 by default and it has to be obtained separately from.

If you don’t like the X11 style of widgets and use command-line R you would probably want to build R using the Aqua version of Tcl/Tk (see the ‘R Installation and Administration Manual’). Note, however, that such builds do not work when used in the R.APP GUI. Next:, Previous:, Up: 7 Internationalization of the R.app R and the R.APP GUI introduced support for internationalization in R 2.1.0. Among other things this means that both messages and GUI elements can be translated into various languages. R.APP automatically detects user’s settings in the International section of the System Preferences and uses that information to offer translated messages and GUI if available. Please note that both Language and Formats information is used so they should be set up consistently.

If you use a non-standard setup (e.g. Different language than formats), you can override the auto-detection performed by setting ‘ force.LANG’ defaults setting, such as for example. System('defaults write org.R-project.R force.LANG enUS.UTF-8') but do not forget to quit R and start R.APP again afterwards. Please note that you must always use ‘.UTF-8’ version of the locale, otherwise R.APP will not work properly. By default R.APP uses UTF-8 for newly created documents and for the console. When opening new documents R.APP assumes UTF-8 and only if the document violates UTF-8 rules, it will try to fallback to legacy encoding, usually Mac Roman.

If you are interested in translating R.APP GUI into other languages, please read the developer documentation at. Next:, Previous:, Up: 10.4 I see spurious error messages when starting R! If you see error messages upon start of the R GUI which contain Library/InputManagers anywhere in the text, then you have some broken haxxies installed in your system. Those messages do NOT come from R, so don’t blame us. Bundles located in Library/InputManagers of your home (or system) are hacks that get loaded into every Mac application that you start. In most cases you don’t see them crashing, because most applications don’t show the console output, but R does, so all the errors those hacks are causing become visible. The easiest remedy is to delete all offending bundles (possibly the whole Library/InputManagers folder) and get a fixed version of the hack (if you need it).

The most common cause for broken hacks is system updgrade (e.g. You get a new Mac and you transfer you settings which include those hacks that are incompatible with your new Mac). If you want to disable all external error output in the GUI, use. Next:, Previous:, Up: 10.5 Which BLAS is used and how can it be changed? The BLAS library used by R depends on the way R was compiled (see ‘R Installation and Administration’ manual for details).

Current R binaries supplied from CRAN provide both vecLib-based BLAS and reference BLAS shipped with R. VecLib is a part of Apple’s Accelerate framework which provides an optimized BLAS implementation for Mac hardware. Although fast, it is not under our control and may possibly deliver inaccurate results. The CRAN binary uses -enable-BLAS-shlib option and two Rblas shared libraries are supplied: libRblas.vecLib.dylib which uses vecLib BLAS and libRblas.0.dylib which uses reference BLAS from R. A symbolic link libRblas.dylib determines which one is used. Currently the default is to use the R BLAS: this is recommended for precision.

In order to change which BLAS is used, change the libRblas.dylib symlink correspondingly – for example in Terminal. Next:, Previous:, Up: 10.7 Why are there faint lines in image plots? When plots based on the image function are exported to PDF, Preview shows very faint grid lines at the edges of the rectangles that create the image. Those lines are a rendering artifact in Preview coming from the combination of anti-aliasing and sub-pixel rendering. They are not really a part of the PDF (zooming in will reveal that they are not a real object which would get larger with zoom) since the rectangles are defined as a gapless coverage of the area. The effect can be circumvented by disabling anti-aliasing in Preview. We correct for this effect in Quartz when rendering on-screen by snapping all rectangles to pixel boundaries of the screen, but Preview does not.

The same effect occurs in any plot with adjacent, filled polygons without border. Next:, Previous:, Up: 10.8 Why doesn’t R GUI support keyboard shortcut XYZ? The R.APP GUI uses Apple frameworks for text editing and thus the behavior of text views (console, editor, etc.) is consistent with other applications and allows a very flexible customization. For example if you are not satisfied with the default Emacs-like key bindings that Mac OS X provides, Apple allows you to extend them arbitrarily.

For more details see Apple’s documentation on. There are also many 3rd-party pages on key bindings customization, search for StandardKeyBinding.dict. Next:, Previous:, Up: 10.10 Why is R.home in the R framework not versioned?

In the command line version of R, R.home always points to the Resources directory symbolic link inside the R framework which points to Versions/Current/Resource which is turn points to the actual home – a versioned directory such as for example Versions/3.0/Resources. This is how framework versioning works in Mac OS X and is defined by Apple (see ). The advantage of this setup is that it is possible to install multiple R versions in parallel and they all will be fully functional as long as the Current symbolic link points to the currently used version. There is even a small GUI utility RSwitch available from the that allows you to select the desired version. In addition, any application embedding R can choose to use a specific R version (in most cases) or any version. Note that R.APP is compiled against a particular version of R and it may crash if RSwitch is used to change the version of R in use. Although it is possible to set RHOME directly to the versioned path in the R shell scripts (and thus be able to run different version in parallel without changing the symbolic link), there are several dangers lurking there so we don’t recommend it.

One problem is that building packages from source won’t work. The linker is always linking against the current version of the framework and therefore only the currently active version of R can compile packages. Further, packages may have used the value of R.home at install time and thus may not work with incorrect setting. Finally, if such an R start script happens to get copied and the R version changes, it will stop working. Next:, Previous:, Up: 10.11 R.app GUI crashes on startup! If your R.APP GUI crashes on startup, there are two common causes for this: a saved workspace or a corrupted history file.

(Another is a mismatch between R.APP and R if either has been updated or RSwitch has been used.) Saved workspaces can contain commands that implicitly load packages which in turn can trigger bugs in packages or feed R with incorrect starting values (especially if it was saved using another R). Try removing or renaming your workspace – it’s called.RData. If you did not change your startup settings, you can e.g.

Next:, Previous:, Up: 10.13 I get “command not found” in the GUI yet it works in the Terminal – why? When executing system commands (for example directly via system or indirectly via functions that call other programs such as install.packages) the locations in which the shell is looking for programs is governed by the PATH environment variable. That variable may be set differently for R started from an interactive shell and for R started in the GUI.

You can use Sys.getenv('PATH') to verify the current setting. When R is started from a shell (e.g., on the command line of the Terminal), it will inherit settings from that shell. Those are typically modified by shell-specific configuration files, such as.profile or.bashrc. Those apply only to the shell, not to the system as a whole. In addition, some installers (such as MacTeX) will modify global shell settings to make user’s life more comfortable on the command line, but, again, those do not apply to programs not started from the shell – such as GUIs. See for what Apple says about the topic.

In order to standardize your PATH setting in R, you can set it in your.Renviron file (in your home directory – see?Startup in R for details on how R uses configuration files on startup). This setting will apply to R regardless of how it is started. You can also add more elaborate constructs to.Rprofile instead if you wish to selectively modify the existing PATH variable via Sys.getenv and Sys.setenv. Previous:, Up: 10.15 I get “clang: error: unsupported option -fopenmp” when compiling a package – why? CRAN binaries for the El Capitan build (the main build since R 3.4.0) come with OpenMP support (it is a way to parallelize many operations and thus make R faster), which is only available in recent Clang compilers. In order to compile packages you must install a Clang compiler with OpenMP support, we provide one in the tools section on CRAN:.

Apple’s Clang that comes with Xcode does not support OpenMP and thus cannot be used. For details please see the instructions on the aforementioned CRAN tools page – for example, if you use our clang binary then you can set PATH=/usr/local/clang6/bin:$PATH or set the full paths to the tools in /.R/Makevars. If you see the error clang: error: unsupported option '-fopenmp' then you are not using the correct clang compiler.

This content has been, and is no longer maintained by Indiana University. Resources linked from this page may no longer be available or reliable. Although it is occasionally used to represent other formats, a.bin extension indicates that the file has most likely been encoded in MacBinary, a file encoding protocol common to Mac OS, and to a lesser extent, Mac OS X. The file is probably an archive, application, or other binary file encoded to protect the Mac's forked file structure. To decode a MacBinary document in Mac OS, Mac OS X, or Windows, use StuffIt Expander.

Simply drag and drop the file onto the StuffIt Expander icon and it will decode the file. When necessary, it will also decompress the file into a usable form. If dragging and dropping doesn't work, double-click the StuffIt Expander icon and, from the File menu, select Expand. In the Open dialog box that appears, choose the file you wish to convert. Most dedicated and programs (e.g., Transmit and Fetch) can also decode MacBinary files, and so can some mail clients. Other programs, such as Internet Explorer, will automatically decode any file with the.bin extension as long as StuffIt Expander is installed.

StuffIt Expander is available from. The Mac version is included with later versions of Mac OS and early versions of Mac OS X (up through OS X 10.3.x).

Note: To correctly decode MacBinary III files, you must have StuffIt Expander 5.0 or higher. Older versions will work to some extent, but won't extract icon badges and routing information, which are Finder features introduced in Mac OS 8.5.