On this page:
2.1 API for Creating Executables
create-embedding-executable
make-embedding-executable
write-module-bundle
embedding-executable-is-directory?
embedding-executable-is-actually-directory?
embedding-executable-put-file-extension+  style+  filters
embedding-executable-add-suffix
2.1.1 Executable Creation Signature
compiler:  embed^
2.1.2 Executable Creation Unit
compiler:  [email protected]
2.1.3 Finding the Racket Executable
find-exe
2.2 Installation-Specific Launchers
2.2.1 Creating Launchers
make-gracket-launcher
make-racket-launcher
make-gracket-program-launcher
make-racket-program-launcher
install-gracket-program-launcher
install-racket-program-launcher
make-mred-launcher
make-mred-program-launcher
install-mred-program-launcher
make-mzscheme-launcher
make-mzscheme-program-launcher
install-mzscheme-program-launcher
2.2.2 Launcher Path and Platform Conventions
gracket-program-launcher-path
racket-program-launcher-path
gracket-launcher-is-directory?
racket-launcher-is-directory?
gracket-launcher-is-actually-directory?
racket-launcher-is-actually-directory?
gracket-launcher-add-suffix
racket-launcher-add-suffix
gracket-launcher-put-file-extension+  style+  filters
racket-launcher-put-file-extension+  style+  filters
mred-program-launcher-path
mred-launcher-is-directory?
mred-launcher-is-actually-directory?
mred-launcher-add-suffix
mred-launcher-put-file-extension+  style+  filters
mzscheme-program-launcher-path
mzscheme-launcher-is-directory?
mzscheme-launcher-is-actually-directory?
mzscheme-launcher-add-suffix
mzscheme-launcher-put-file-extension+  style+  filters
installed-executable-path->desktop-path
installed-desktop-path->icon-path
2.2.3 Launcher Configuration
gracket-launcher-up-to-date?
racket-launcher-up-to-date?
build-aux-from-path
extract-aux-from-path
current-launcher-variant
available-gracket-variants
available-racket-variants
mred-launcher-up-to-date?
mzscheme-launcher-up-to-date?
available-mred-variants
available-mzscheme-variants
2.2.4 Launcher Creation Signature
launcher^
2.2.5 Launcher Creation Unit
[email protected]
2.3 Mac OS Dynamic Library Paths
find-matching-library-path
update-matching-library-path

2 raco exe: Creating Stand-Alone Executables

To achieve a faster startup time, instead of trying raco exe, use a smaller base language—such as #lang racket/base instead of #lang racket. Also, ensure that bytecode files are compiled by using raco make.

Compiled code produced by raco make relies on Racket executables to provide run-time support to the compiled code. However, raco exe can package code together with its run-time support to form an executable, and raco distribute can package the executable into a distribution that works on other machines. Running an executable produced by raco exe will not improve performance over raco make.

The raco exe command embeds a module, from source or byte code, into a copy of the racket executable. (On Unix, the embedding executable is actually a copy of a wrapper executable.) The created executable invokes the embedded module on startup. The --gui flag causes the program to be embedded in a copy of the gracket executable. If the embedded module refers to other modules via require, then the other modules are also included in the embedding executable.

For example, the command

  raco exe --gui hello.rkt

produces either "hello.exe" (Windows), "hello.app" (Mac OS), or "hello" (Unix), which runs the same as running the "hello.rkt" module in gracket.

Library modules or other files that are referenced dynamically—through eval, load, or dynamic-requireare not automatically embedded into the created executable. Such modules can be explicitly included using the ++lib flag to raco exe. Alternately, use define-runtime-path to embed references to the run-time files in the executable; the files are then copied and packaged together with the executable when creating a distribution (as described in raco distribute: Sharing Stand-Alone Executables). Finally, a submodule is included if its enclosing module is included and the submodule contains a sub-submodule named declare-preserve-for-embedding (where the implementation of the sub-submodule is ignored).

Modules that are implemented directly by extensions—i.e., extensions that are automatically loaded from (build-path "compiled" "native" (system-library-subpath)) to satisfy a requireare treated like other run-time files: a generated executable uses them from their original location, and they are copied and packaged together when creating a distribution.

The raco exe command works only with module-based programs. The compiler/embed library provides a more general interface to the embedding mechanism.

A stand-alone executable is “stand-alone” in the sense that you can run it without starting racket, gracket, or DrRacket. However, the executable depends on Racket shared libraries, and possibly other run-time files declared via define-runtime-path. The executable can be packaged with support libraries to create a distribution using raco distribute, as described in raco distribute: Sharing Stand-Alone Executables.

The raco exe command accepts the following command-line flags:

Changed in version 6.3.0.11: Added support for declare-preserve-for-embedding.

2.1 API for Creating Executables

 (require compiler/embed) package: base
The compiler/embed library provides a function to embed Racket code into a copy of Racket or GRacket, thus creating a stand-alone Racket executable. To package the executable into a distribution that is independent of your Racket installation, use assemble-distribution from compiler/distribute.

Embedding walks the module dependency graph to find all modules needed by some initial set of top-level modules, compiling them if needed, and combining them into a “module bundle.” In addition to the module code, the bundle extends the module name resolver, so that modules can be required with their original names, and they will be retrieved from the bundle instead of the filesystem.

The create-embedding-executable function combines the bundle with an executable (Racket or GRacket). The write-module-bundle function prints the bundle to the current output port, instead; this stream can be loaded directly by a running program, as long as the read-accept-compiled parameter is true.

procedure

(create-embedding-executable 
  dest 
  #:modules mod-list 
  [#:early-literal-expressions early-literal-sexps 
  #:configure-via-first-module? config-via-first? 
  #:literal-files literal-files 
  #:literal-expression literal-sexp 
  #:literal-expressions literal-sexps 
  #:cmdline cmdline 
  #:gracket? gracket? 
  #:mred? mred? 
  #:variant variant 
  #:aux aux 
  #:collects-path collects-path 
  #:collects-dest collects-dest 
  #:launcher? launcher? 
  #:verbose? verbose? 
  #:expand-namespace expand-namespace 
  #:compiler compile-proc 
  #:src-filter src-filter 
  #:on-extension ext-proc 
  #:get-extra-imports extras-proc]) 
  void?
  dest : path-string?
  mod-list : 
(listof (or/c (list/c (or/c symbol? (one-of/c #t #f))
                      (or/c module-path? path?))
              (list/c (or/c symbol? (one-of/c #t #f))
                      (or/c module-path? path?)
                      (listof symbol?))))
  early-literal-sexps : list? = null
  config-via-first? : any/c = #f
  literal-files : (listof path-string?) = null
  literal-sexp : any/c = #f
  literal-sexps : list? = 
(if literal-sexp
    (list literal-sexp)
    null)
  cmdline : (listof string?) = null
  gracket? : any/c = #f
  mred? : any/c = #f
  variant : (or/c 'cgc '3m) = (system-type 'gc)
  aux : (listof (cons/c symbol? any/c)) = null
  collects-path : 
(or/c #f
      path-string?
      (listof path-string?))
 = #f
  collects-dest : (or/c #f path-string?) = #f
  launcher? : any/c = #f
  verbose? : any/c = #f
  expand-namespace : namespace? = (current-namespace)
  compile-proc : (any/c . -> . compiled-expression?)
   = 
(lambda (e)
  (parameterize ([current-namespace
                  expand-namespace])
    (compile e)))
  src-filter : (path? . -> . any) = (lambda (p) #t)
  ext-proc : (or/c #f (path-string? boolean? . -> . any)) = #f
  extras-proc : 
(path? compiled-module-expression?
 . -> . (listof module-path?))
   = (lambda (p m) null)
Copies the Racket (if gracket? and mred? are #f) or GRacket (otherwise) binary, embedding code into the copied executable to be loaded on startup. On Unix, the binary is actually a wrapper executable that execs the original; see also the 'original-exe? tag for aux.

The embedding executable is written to dest, which is overwritten if it exists already (as a file or directory).

The embedded code consists of module declarations followed by additional (arbitrary) code. When a module is embedded, every module that it imports is also embedded. Library modules are embedded so that they are accessible via their lib paths in the initial namespace except as specified in mod-list, other modules (accessed via local paths and absolute paths) are embedded with a generated prefix, so that they are not directly accessible.

The #:modules argument mod-list designates modules to be embedded, as described below. The #:early-literal-expressions, #:literal-files, and #:literal-expressions arguments specify literal code to be copied into the executable: each element of early-literal-sexps is copied in order, then the content of each file in literal-files in order (with no intervening spaces), and then each element of literal-sexps. The literal-files files or early-literal-sexps or literal-sexps lists can contain compiled bytecode, and it’s possible that the content of the literal-files files only parse when concatenated; the files and expression are not compiled or inspected in any way during the embedding process. Beware that the initial namespace contains no bindings; use compiled expressions to bootstrap the namespace. The #:literal-expression (singular) argument is for backward compatibility.

If the #:configure-via-first-module? argument is specified as true, then the language of the first module in mod-list is used to configure the run-time environment before the expressions added by #:literal-files and #:literal-expressions are evaluated, but after the expressions of #:early-literal-expressions. See also Language Run-Time Configuration.

The #:cmdline argument cmdline contains command-line strings that are prefixed onto any actual command-line arguments that are provided to the embedding executable. A command-line argument that evaluates an expression or loads a file will be executed after the embedded code is loaded.

Each element of the #:modules argument mod-list is a two- or three-item list, where the first item is a prefix for the module name, and the second item is a module path datum (that’s in the format understood by the default module name resolver), and the third is a list of submodule names to be included if they are available. The prefix can be a symbol, #f to indicate no prefix, or #t to indicate an auto-generated prefix. For example,

'((#f "m.rkt"))

embeds the module m from the file "m.rkt", without prefixing the name of the module; the literal-sexpr argument to go with the above might be '(require m). When submodules are available and included, the submodule is given a name by symbol-appending the write form of the submodule path to the enclosing module’s name.

Modules are normally compiled before they are embedded into the target executable; see also #:compiler and #:src-filter below. When a module declares run-time paths via define-runtime-path, the generated executable records the path (for use both by immediate execution and for creating a distribution that contains the executable).

If collects-dest is a path instead of #f, then instead of embedding collection-based modules into the executable, the modules (in compiled form, only) are copied into collections in the collects-dest directory.

The optional #:aux argument is an association list for platform-specific options (i.e., it is a list of pairs where the first element of the pair is a key symbol and the second element is the value for that key). See also build-aux-from-path. The currently supported keys are as follows:

If the #:collects-path argument is #f, then the created executable maintains its built-in (relative) path to the main "collects" directory—which will be the result of (find-system-path 'collects-dir) when the executable is run—plus a potential list of other directories for finding library collections—which are used to initialize the current-library-collection-paths list in combination with the PLTCOLLECTS environment variable. Otherwise, the argument specifies a replacement; it must be either a path, string, or list of paths and strings. In the last case, the first path or string specifies the main collection directory, and the rest are additional directories for the collection search path (placed, in order, after the user-specific "collects" directory, but before the main "collects" directory; then the search list is combined with PLTCOLLECTS, if it is defined). If the list is empty, then (find-system-path 'collects-dir) will return the directory of the executable, but current-library-collection-paths is initialized to an empty list, and use-collection-link-paths is set to false to disable the use of collection links files.

If the #:launcher? argument is #t, then mod-list should be null, literal-files should be null, literal-sexp should be #f, and the platform should be Windows or Mac OS. The embedding executable is created in such a way that (find-system-path 'exec-file) produces the source Racket or GRacket path instead of the embedding executable (but the result of (find-system-path 'run-file) is still the embedding executable).

The #:variant argument indicates which variant of the original binary to use for embedding. The default is (system-type 'gc); see also current-launcher-variant.

The #:compiler argument is used to compile the source of modules to be included in the executable (when a compiled form is not already available). It should accept a single argument that is a syntax object for a module form. The default procedure uses compile parameterized to set the current namespace to expand-namespace.

The #:expand-namespace argument selects a namespace for expanding extra modules (and for compiling using the default compile-proc). Extra-module expansion is needed to detect run-time path declarations in included modules, so that the path resolutions can be directed to the current locations (and, ultimately, redirected to copies in a distribution).

The #:src-filter src-filter argument takes a path and returns true if the corresponding file source should be included in the embedding executable in source form (instead of compiled form), #f otherwise. The default returns #f for all paths. Beware that the current output port may be redirected to the result executable when the filter procedure is called. Each path given to src-filter corresponds to the actual file name (e.g., ".ss"/".rkt" conversions have been applied as needed to refer to the existing file).

If the #:on-extension argument is a procedure, the procedure is called when the traversal of module dependencies arrives at an extension (i.e., a DLL or shared object). The default, #f, causes a reference to a single-module extension (in its current location) to be embedded into the executable. The procedure is called with two arguments: a path for the extension, and a #f (for historical reasons).

The #:get-extra-imports extras-proc argument takes a source pathname and compiled module for each module to be included in the executable. It returns a list of quoted module paths (absolute, as opposed to relative to the module) for extra modules to be included in the executable in addition to the modules that the source module requires. For example, these modules might correspond to reader extensions needed to parse a module that will be included as source, as long as the reader is referenced through an absolute module path. Each path given to extras-proc corresponds to the actual file name (e.g., ".ss"/".rkt" conversions have been applied as needed to refer to the existing file).

procedure

(make-embedding-executable dest    
  mred?    
  verbose?    
  mod-list    
  literal-files    
  literal-sexp    
  cmdline    
  [aux    
  launcher?    
  variant    
  collects-path])  void?
  dest : path-string?
  mred? : any/c
  verbose? : any/c
  mod-list : 
(listof (or/c (list/c (or/c symbol? (one-of/c #t #f))
                      (or/c module-path? path?))
              (list/c (or/c symbol? (one-of/c #t #f))
                      (or/c module-path? path?)
                      (listof symbol?))))
  literal-files : (listof path-string?)
  literal-sexp : any/c
  cmdline : (listof string?)
  aux : (listof (cons/c symbol? any/c)) = null
  launcher? : any/c = #f
  variant : (one-of/c 'cgc '3m) = (system-type 'gc)
  collects-path : 
(or/c #f
      path-string?
      (listof path-string?))
 = #f
Old (keywordless) interface to create-embedding-executable.

procedure

(write-module-bundle verbose?    
  mod-list    
  literal-files    
  literal-sexp)  void?
  verbose? : any/c
  mod-list : 
(listof (or/c (list/c (or/c symbol? (one-of/c #t #f))
                      (or/c module-path? path?))
              (list/c (or/c symbol? (one-of/c #t #f))
                      (or/c module-path? path?)
                      (listof symbol?))))
  literal-files : (listof path-string?)
  literal-sexp : any/c
Like make-embedding-executable, but the module bundle is written to the current output port instead of being embedded into an executable. The output of this function can be read to load and instantiate mod-list and its dependencies, adjust the module name resolver to find the newly loaded modules, evaluate the forms included from literal-files, and finally evaluate literal-sexpr. The read-accept-compiled parameter must be true to read the stream.

procedure

(embedding-executable-is-directory? mred?)  boolean

  mred? : any/c
Indicates whether Racket/GRacket executables for the current platform correspond to directories from the user’s perspective. The result is currently #f for all platforms.

procedure

(embedding-executable-is-actually-directory? mred?)  boolean?

  mred? : any/c
Indicates whether Racket/GRacket executables for the current platform actually correspond to directories. The result is #t on Mac OS when mred? is #t, #f otherwise.

procedure

(embedding-executable-put-file-extension+style+filters mred?)

  
(or/c string? false/c)
(listof (one-of/c 'packages 'enter-packages))
(listof (list/c string? string?))
  mred? : any/c
Returns three values suitable for use as the extension, style, and filters arguments to put-file, respectively.

If Racket/GRacket launchers for the current platform were directories from the user’s perspective, the style result is suitable for use with get-directory, and the extension result may be a string indicating a required extension for the directory name.

procedure

(embedding-executable-add-suffix path    
  mred?)  path-string?
  path : path-string?
  mred? : any/c
Adds a suitable executable suffix, if it’s not present already.

2.1.1 Executable Creation Signature

 (require compiler/embed-sig) package: compiler-lib

signature

compiler:embed^ : signature

Includes the identifiers provided by compiler/embed.

2.1.2 Executable Creation Unit

 (require compiler/embed-unit) package: compiler-lib

A unit that imports nothing and exports compiler:embed^.

2.1.3 Finding the Racket Executable

 (require compiler/find-exe) package: base

procedure

(find-exe [#:cross? cross?    
  #:untetherd? untethered?    
  gracket?    
  variant])  path?
  cross? : any/c = #f
  untethered? : any/c = #f
  gracket? : any/c = #f
  variant : (or/c 'cgc '3m) = 
(if cross?
    (cross-system-type 'gc)
    (system-type 'gc))
Finds the path to the racket or gracket (when gracket? is true) executable.

If cross? is true, the executable is found for the target platform in cross-installation mode.

If untethered? is true, then the original executable is found, instead of an executable that is tethered to a configuration or addon directory via (find-addon-tethered-console-bin-dir) and related functions.

Changed in version 6.2.0.5 of package base: Added the #:untethered? argument.
Changed in version 6.3: Added the #:cross? argument.

2.2 Installation-Specific Launchers

A launcher is similar to a stand-alone executable, but a launcher is usually smaller and can be created more quickly, because it depends permanently on the local Racket installation and the program’s sources. In the case of Unix, a launcher is simply a shell script that runs racket or gracket. Launchers cannot be packaged into a distribution using raco distribute. The raco exe command creates a launcher when the -l or --launcher flag is specified.

 (require launcher/launcher) package: base

The launcher/launcher library provides functions for creating launchers.

2.2.1 Creating Launchers

procedure

(make-gracket-launcher args    
  dest    
  [aux    
  #:tether-mode tether-mode])  void?
  args : (listof string?)
  dest : path-string?
  aux : (listof (cons/c symbol? any/c)) = null
  tether-mode : (or/c 'addon 'config #f) = 'addon
Creates the launcher dest, which starts GRacket with the command-line arguments specified as strings in args. Extra arguments passed to the launcher at run-time are appended (modulo special Unix/X flag handling, as described below) to this list and passed on to GRacket. If dest exists already, as either a file or directory, it is replaced.

The optional aux argument is an association list for platform-specific options (i.e., it is a list of pairs where the first element of the pair is a key symbol and the second element is the value for that key). See also build-aux-from-path. See create-embedding-executable for a list that applies to both stand-alone executables and launchers on Windows and Mac OS GRacket; the following additional associations apply to launchers:

For Unix/X, the script created by make-mred-launcher detects and handles X Windows flags specially when they appear as the initial arguments to the script. Instead of appending these arguments to the end of args, they are spliced in after any X Windows flags already listed in args. The remaining arguments (i.e., all script flags and arguments after the last X Windows flag or argument) are then appended after the spliced args.

The tether-mode argument indicates how much to preserve the current installation’s tethering to a configuration directory and/or addon directory based on (find-addon-tether-console-bin-dir) and (find-config-tether-console-bin-dir). The 'addon mode allows full tethering, the 'config mode allows only configuration-directory tethering, and the #f mode disables tethering.

Changed in version 6.5.0.2 of package base: Added the #:tether-mode argument.

procedure

(make-racket-launcher args dest [aux])  void?

  args : (listof string?)
  dest : path-string?
  aux : (listof (cons/c symbol? any/c)) = null
Like make-gracket-launcher, but for starting Racket. On Mac OS, the 'exe-name aux association is ignored.

procedure

(make-gracket-program-launcher file    
  collection    
  dest)  void?
  file : string?
  collection : string?
  dest : path-string?
Calls make-gracket-launcher with arguments that start the GRacket program implemented by file in collection: (list "-l-" (string-append collection "/" file)). The aux argument to make-gracket-launcher is generated by stripping the suffix (if any) from file, adding it to the path of collection, and passing the result to build-aux-from-path.

procedure

(make-racket-program-launcher file    
  collection    
  dest)  void?
  file : string?
  collection : string?
  dest : path-string?

procedure

(install-gracket-program-launcher file    
  collection    
  name)  void?
  file : string?
  collection : string?
  name : string?
Same as

(make-gracket-program-launcher
 file collection
 (gracket-program-launcher-path name))

procedure

(install-racket-program-launcher file    
  collection    
  name)  void?
  file : string?
  collection : string?
  name : string?
Same as

(make-racket-program-launcher
 file collection
 (racket-program-launcher-path name))

procedure

(make-mred-launcher args dest [aux])  void?

  args : (listof string?)
  dest : path-string?
  aux : (listof (cons/c symbol? any/c)) = null

procedure

(make-mred-program-launcher file    
  collection    
  dest)  void?
  file : string?
  collection : string?
  dest : path-string?

procedure

(install-mred-program-launcher file    
  collection    
  name)  void?
  file : string?
  collection : string?
  name : string?
Backward-compatible version of make-gracket-launcher, etc., that adds "-I" "scheme/gui/init" to the start of the command-line arguments.

procedure

(make-mzscheme-launcher args dest [aux])  void?

  args : (listof string?)
  dest : path-string?
  aux : (listof (cons/c symbol? any/c)) = null

procedure

(make-mzscheme-program-launcher file    
  collection    
  dest)  void?
  file : string?
  collection : string?
  dest : path-string?

procedure

(install-mzscheme-program-launcher file    
  collection    
  name)  void?
  file : string?
  collection : string?
  name : string?
Backward-compatible version of make-racket-launcher, etc., that adds "-I" "scheme/init" to the start of the command-line arguments.

2.2.2 Launcher Path and Platform Conventions

procedure

(gracket-program-launcher-path name    
  [#:user? user?    
  #:tethered? tethered?    
  #:console? console?])  path?
  name : string?
  user? : any/c = #f
  tethered? : any/c = #f
  console? : any/c = #f
Returns a pathname for an executable called something like name in

For Windows, the ".exe" suffix is automatically appended to name. For Unix, name is changed to lowercase, whitespace is changed to -, and the path includes the "bin" subdirectory of the Racket installation. For Mac OS, the ".app" suffix is appended to name.

If console? is true, then the path is in the console executable directory, such as the one reported by (find-console-bin-dir), instead of the GUI executable directory, such as the one reported by (find-gui-bin-dir).

Changed in version 6.5.0.2 of package base: Added the #:tethered? argument.
Changed in version 6.8.0.2: Added the #:console? argument.

procedure

(racket-program-launcher-path name    
  [#:user? user?    
  #:tethered? tethered?    
  #:console? console?])  path?
  name : string?
  user? : any/c = #f
  tethered? : any/c = #f
  console? : any/c = #f
Returns the same path as (gracket-program-launcher-path name #:user? user? #:tethered tethered? #:console? console?).

Changed in version 6.5.0.2 of package base: Added the #:tethered? argument.
Changed in version 6.8.0.2: Added the #:console? argument.

Returns #t if GRacket launchers for the current platform are directories from the user’s perspective. For all currently supported platforms, the result is #f.

Like gracket-launcher-is-directory?, but for Racket launchers.

Returns #t if GRacket launchers for the current platform are implemented as directories from the filesystem’s perspective. The result is #t for Mac OS, #f for all other platforms.

Like gracket-launcher-is-actually-directory?, but for Racket launchers. The result is #f for all platforms.

procedure

(gracket-launcher-add-suffix path-string?)  path?

  path-string? : path
Returns a path with a suitable executable suffix added, if it’s not present already.

procedure

(racket-launcher-add-suffix path-string?)  path?

  path-string? : path
Like gracket-launcher-add-suffix, but for Racket launchers.

Returns three values suitable for use as the extension, style, and filters arguments to put-file, respectively.

If GRacket launchers for the current platform were directories from the user’s perspective, the style result is suitable for use with get-directory, and the extension result may be a string indicating a required extension for the directory name.

Like gracket-launcher-get-file-extension+style+filters, but for Racket launchers.

procedure

(mred-program-launcher-path name    
  [#:user? user?    
  #:tethered? tethered?])  path?
  name : string?
  user? : any/c = #f
  tethered? : any/c = #f

procedure

(mred-launcher-is-directory?)  boolean?

procedure

(mred-launcher-is-actually-directory?)  boolean?

procedure

(mred-launcher-add-suffix path-string?)  path?

  path-string? : path

procedure

(mred-launcher-put-file-extension+style+filters)

  
(or/c string? false/c)
(listof (one-of/c 'packages 'enter-packages))
(listof (list/c string? string?))
Backward-compatible aliases for gracket-program-launcher-path, etc.

Changed in version 6.5.0.2 of package base: Added the #:tethered? argument.

procedure

(mzscheme-program-launcher-path name    
  [#:user? user?    
  #:tethered? tethered?])  path?
  name : string?
  user? : any/c = #f
  tethered? : any/c = #f

procedure

(mzscheme-launcher-is-directory?)  boolean?

procedure

(mzscheme-launcher-is-actually-directory?)  boolean?

procedure

(mzscheme-launcher-add-suffix path-string?)  path?

  path-string? : path

procedure

(mzscheme-launcher-put-file-extension+style+filters)

  
(or/c string? false/c)
(listof (one-of/c 'packages 'enter-packages))
(listof (list/c string? string?))
Backward-compatible aliases for racket-program-launcher-path, etc.

Changed in version 6.5.0.2 of package base: Added the #:tethered? argument.

procedure

(installed-executable-path->desktop-path exec-path 
  user?) 
  (and/c path? complete-path?)
  exec-path : path-string?
  user? : any/c
Returns a path for a ".desktop" file to describe the installed executable at exec-path. Only the filename part of exec-path is used. The user? argument should be true if exec-path is installed in a user-specific location (in which case the result path will also be user-specific).

procedure

(installed-desktop-path->icon-path desktop-path 
  user? 
  suffix) 
  (and/c path? complete-path?)
  desktop-path : path-string?
  user? : any/c
  suffix : bytes?
Returns a path for an icon file to be referenced by the "desktop" file at desktop-path. Only the filename part of desktop-path is used. The user? argument should be true if desktop-path is installed in a user-specific location (in which case the result path will also be user-specific). The suffix argument provides the icon-file suffix, normally either #"png" or #"ico".

2.2.3 Launcher Configuration

procedure

(gracket-launcher-up-to-date? dest aux)  boolean?

  dest : path-string?
  aux : (listof (cons/c symbol? any/c))
Returns #t if the GRacket launcher dest does not need to be updated, assuming that dest is a launcher and its arguments have not changed.

procedure

(racket-launcher-up-to-date? dest aux)  boolean?

  dest : path-string?
  aux : (listof (cons/c symbol? any/c))
Analogous to gracket-launcher-up-to-date?, but for a Racket launcher.

procedure

(build-aux-from-path path)  (listof (cons/c symbol? any/c))

  path : path-string?
Creates an association list suitable for use with make-gracket-launcher or create-embedding-executable. It builds associations by adding to path suffixes, such as ".icns", checking whether such a file exists, and calling extract-aux-from-path if so. The results from all recognized suffixes are appended together.

procedure

(extract-aux-from-path path)  (listof (cons/c symbol? any/c))

  path : path-string?
Creates an association list suitable for use with make-gracket-launcher or create-embedding-executable. It builds associations by recognizing the suffix of path, where the recognized suffixes are as follows:

parameter

(current-launcher-variant)  symbol?

(current-launcher-variant variant)  void?
  variant : symbol?
A parameter that indicates a variant of Racket or GRacket to use for launcher creation and for generating launcher names. The default is the result of (system-type 'gc). On Unix and Windows, the possibilities are 'cgc and '3m. On Mac OS, the 'script-3m and 'script-cgc variants are also available for GRacket launchers.

Returns a list of symbols corresponding to available variants of GRacket in the current Racket installation. The list normally includes at least one of '3m or 'cgc whichever is the result of (system-type 'gc)and may include the other, as well as 'script-3m and/or 'script-cgc on Mac OS.

Returns a list of symbols corresponding to available variants of Racket in the current Racket installation. The list normally includes at least one of '3m or 'cgcwhichever is the result of (system-type 'gc)and may include the other.

procedure

(mred-launcher-up-to-date? dest aux)  boolean?

  dest : path-string?
  aux : (listof (cons/c symbol? any/c))

procedure

(mzscheme-launcher-up-to-date? dest aux)  boolean?

  dest : path-string?
  aux : (listof (cons/c symbol? any/c))

procedure

(available-mred-variants)  (listof symbol?)

procedure

(available-mzscheme-variants)  (listof symbol?)

Backward-compatible aliases for gracket-launcher-up-to-date?, etc.

2.2.4 Launcher Creation Signature

 (require launcher/launcher-sig) package: compiler-lib

signature

launcher^ : signature

Includes the identifiers provided by launcher/launcher.

2.2.5 Launcher Creation Unit

 (require launcher/launcher-unit) package: compiler-lib

A unit that imports nothing and exports launcher^.

2.3 Mac OS Dynamic Library Paths

 (require compiler/exe-dylib-path) package: base
The compiler/exe-dylib-path library provides functions for reading and adjusting dynamic-library references in a Mac OS executable.

Added in version 6.3 of package base.

procedure

(find-matching-library-path exe-path    
  library-str)  (or/c #f string?)
  exe-path : path-string?
  library-str : string?
Searches dynamic-linking information in exe-path for a library reference whose name includes library-str and returns the executable’s path to the library for the first match. If no match is found, the result is #f.

procedure

(update-matching-library-path exe-path    
  library-str    
  library-path-str)  void?
  exe-path : path-string?
  library-str : string?
  library-path-str : string?
Searches dynamic-linking information in exe-path for each library reference whose name includes library-str and replaces the executable’s path to that library with library-path-str.

A single match is expected, and the update assumes enough space for the new path, perhaps because the executable is linked with -headerpad_max_install_names.