Establecer variables de entorno en OS X

¿Cuál es la forma correcta de modificar variables de entorno como PATH en OS X?

Miré un poco en Google y encontré tres archivos diferentes para editar:

  • / etc / paths
  • ~ / .profile
  • ~ / .tcshrc

Ni siquiera tengo algunos de estos archivos, y estoy bastante seguro de que .tcshrc está mal, ya que OS X usa bash ahora. ¿Dónde se definen estas variables, especialmente PATH?

Estoy ejecutando OS X v10.5 (Leopard).

Bruno está bien encaminado. He realizado una investigación exhaustiva y si desea establecer variables que están disponibles en todas las aplicaciones de GUI, su única opción es /etc/launchd.conf .

Tenga en cuenta que environment.plist no funciona para las aplicaciones iniciadas a través de Spotlight. Esto está documentado por Steve Sexton aquí .

  1. Abra un mensaje de terminal

  2. Escriba sudo vi /etc/launchd.conf (nota: este archivo podría no existir aún)

  3. Coloque contenidos como los siguientes en el archivo

     # Set environment variables here so they are available globally to all apps # (and Terminal), including those launched via Spotlight. # # After editing this file run the following command from the terminal to update # environment variables globally without needing to reboot. # NOTE: You will still need to restart the relevant application (including # Terminal) to pick up the changes! # grep -E "^setenv" /etc/launchd.conf | xargs -t -L 1 launchctl # # See http://www.digitaledgesw.com/node/31 # and http://stackoverflow.com/questions/135688/setting-environment-variables-in-os-x/ # # Note that you must hardcode the paths below, don't use environment variables. # You also need to surround multiple values in quotes, see MAVEN_OPTS example below. # setenv JAVA_VERSION 1.6 setenv JAVA_HOME /System/Library/Frameworks/JavaVM.framework/Versions/1.6/Home setenv GROOVY_HOME /Applications/Dev/groovy setenv GRAILS_HOME /Applications/Dev/grails setenv NEXUS_HOME /Applications/Dev/nexus/nexus-webapp setenv JRUBY_HOME /Applications/Dev/jruby setenv ANT_HOME /Applications/Dev/apache-ant setenv ANT_OPTS -Xmx512M setenv MAVEN_OPTS "-Xmx1024M -XX:MaxPermSize=512m" setenv M2_HOME /Applications/Dev/apache-maven setenv JMETER_HOME /Applications/Dev/jakarta-jmeter 
  4. Guarde sus cambios en vi y reinicie su Mac. O use el grep / xargs que se muestra en el comentario del código anterior.

  5. Demuestre que sus variables funcionan, abriendo una ventana de Terminal y escribiendo export y debería ver sus nuevas variables. Estos también estarán disponibles en IntelliJ IDEA y otras aplicaciones GUI que ejecute a través de Spotlight.

Cómo configurar el entorno para nuevos procesos iniciado por Spotlight (sin necesidad de reiniciar)

Puede configurar el entorno utilizado por launchd (y, por extensión, cualquier cosa iniciada desde Spotlight) con launchctl setenv . Por ejemplo, para establecer la ruta:

 launchctl setenv PATH /opt/local/bin:/opt/local/sbin:/usr/bin:/bin:/usr/sbin:/sbin 

O si desea configurar su ruta en .bashrc o similar, .bashrc que se refleje en launchd:

 PATH=/opt/local/bin:/opt/local/sbin:/usr/bin:/bin:/usr/sbin:/sbin launchctl setenv PATH $PATH 

No es necesario reiniciar, aunque deberá reiniciar una aplicación si desea que recupere el entorno modificado.

Esto incluye todas las shells que ya se ejecutan bajo Terminal.app, aunque si estás allí puedes establecer el entorno más directamente, por ejemplo, con export PATH=/opt/local/bin:/opt/local/sbin:$PATH para bash o zsh .

Cómo mantener los cambios después de un reinicio

Para mantener los cambios después de un reinicio , puede configurar las variables de entorno desde /etc/launchd.conf , así:

 setenv PATH /opt/local/bin:/opt/local/sbin:/usr/bin:/bin:/usr/sbin:/sbin 

launchd.conf se ejecuta automáticamente cuando reinicias.

Si desea que estos cambios surtan efecto ahora, debe usar este comando para reprocesar launchctl.conf (¡gracias @mklement por la sugerencia!)

 egrep -v '^\s*#' /etc/launchd.conf | launchctl 

Puede obtener más información sobre launchctl y cómo carga launchd.conf con el comando man launchctl .

Hasta e incluyendo OS X v10.7 (Lion) puede configurarlos en:

 ~/.MacOSX/environment.plist 

Ver:

Para PATH en la Terminal, deberías poder establecer en .bash_profile o .profile (probablemente tendrás que crearlo)

Para OS X v10.8 (Mountain Lion) y más allá necesita usar launchd y launchctl .

Solución para aplicaciones de línea de comando y GUI desde una única fuente (funciona con Yosemite y El Capitan)

Supongamos que tiene definiciones de variables de entorno en su ~/.bash_profile como en el siguiente fragmento de código:

 export JAVA_HOME="$(/usr/libexec/java_home -v 1.8)" export GOPATH="$HOME/go" export PATH="$PATH:/usr/local/opt/go/libexec/bin:$GOPATH/bin" export PATH="/usr/local/opt/coreutils/libexec/gnubin:$PATH" export MANPATH="/usr/local/opt/coreutils/libexec/gnuman:$MANPATH" 

Necesitamos un agente de inicio que se ejecutará en cada inicio de sesión y en cualquier momento bajo demanda que va a cargar estas variables a la sesión del usuario. También necesitaremos un script de shell para analizar estas definiciones y crear los comandos necesarios para que el agente los ejecute.

Cree un archivo con sufijo plist (por ejemplo, llamado osx-env-sync.plist ) en el directorio ~/Library/LaunchAgents/ con los siguientes contenidos:

     Label osx-env-sync ProgramArguments  bash -l -c  $HOME/.osx-env-sync.sh   RunAtLoad    

-l parámetro es crítico aquí; es necesario para ejecutar el script de shell con un shell de inicio de sesión para que ~/.bash_profile se obtenga en primer lugar antes de que se ejecute este script.

Ahora, el script de shell. ~/.osx-env-sync.sh en ~/.osx-env-sync.sh con los siguientes contenidos:

 grep export $HOME/.bash_profile | while IFS=' =' read ignoreexport envvar ignorevalue; do launchctl setenv ${envvar} ${!envvar} done 

Asegúrese de que el script de shell sea ejecutable:

 chmod +x ~/.osx-env-sync.sh 

Ahora, cargue el agente de lanzamiento para la sesión actual:

 launchctl load ~/Library/LaunchAgents/osx-env-sync.plist 

(Re) Inicie una aplicación GUI y verifique que pueda leer las variables de entorno.

La configuración es persistente. Sobrevivirá a reinicios y relogines.

Después de la configuración inicial (que acabas de hacer), si deseas reflejar cualquier cambio en tu ~/.bash_profile en todo tu entorno nuevamente, volver a ejecutar el launchctl load ... no realizará lo que quieras; en su lugar, recibirá una advertencia como la siguiente:

<$HOME>/Library/LaunchAgents/osx-env-sync.plist: Operation already in progress

Para volver a cargar las variables de entorno sin pasar por el proceso de cierre de sesión / inicio de sesión, haga lo siguiente:

 launchctl unload ~/Library/LaunchAgents/osx-env-sync.plist launchctl load ~/Library/LaunchAgents/osx-env-sync.plist 

Finalmente, asegúrese de reiniciar las aplicaciones que ya está ejecutando (incluida Terminal.app) para informarlas sobre los cambios.

También introduje el código y las explicaciones aquí en un proyecto de GitHub: osx-env-sync .

Espero que esta sea la solución definitiva, al menos para las últimas versiones de OS X (Yosemite y El Capitán).

1.

 vim ~/.bash_profile 

El archivo puede no existir (si no, puedes simplemente crearlo).

2. Escribe esto y guarda el archivo:

 export PATH=$PATH:YOUR_PATH_HERE 

3.run

 source ~/.bash_profile 

Básicamente hay dos problemas para resolver cuando se trata de variables de entorno en OS X. El primero es cuando se invocan progtwigs de Spotlight (el icono de lupa en el lado derecho del menú / barra de estado de Mac) y el segundo cuando se invocan progtwigs desde el Dock . Invocar progtwigs desde una aplicación / utilidad de Terminal es trivial porque lee el entorno desde las ubicaciones de shell estándar ( ~/.profile , ~/.bash_profile , ~/.bashrc , etc.)

Al invocar progtwigs desde el Dock, use ~/.MacOSX/environment.plist donde el elemento contiene una secuencia de elementos KEYtheValue .

Al invocar progtwigs de Spotlight, asegúrese de que launchd se haya configurado con todas las configuraciones de clave / valor que necesita.

Para resolver ambos problemas simultáneamente, utilizo un elemento de inicio de sesión (configurado a través de la herramienta de Preferencias del sistema) en mi cuenta de usuario. El elemento de inicio de sesión es un script bash que invoca una función de ceceo de Emacs aunque, por supuesto, puede usar su herramienta de scripting favorita para lograr lo mismo. Este enfoque tiene la ventaja adicional de que funciona en cualquier momento y no requiere un reinicio, es decir, uno puede editar ~/.profile , ejecutar el elemento de inicio de sesión en algún shell y tener los cambios visibles para los progtwigs recién invocados, desde el Dock o Destacar.

Detalles:

~/bin/macosx-startup sesión: ~/bin/macosx-startup

 #!/bin/bash bash -l -c "/Applications/Emacs.app/Contents/MacOS/Emacs --batch -l ~/lib/emacs/elisp/macosx/environment-support.el -f generate-environment" 

Función Emacs lisp: ~/lib/emacs/elisp/macosx/envionment-support.el

 ;;; Provide support for the environment on Mac OS X (defun generate-environment () "Dump the current environment into the ~/.MacOSX/environment.plist file." ;; The system environment is found in the global variable: ;; 'initial-environment' as a list of "KEY=VALUE" pairs. (let ((list initial-environment) pair start command key value) ;; clear out the current environment settings (find-file "~/.MacOSX/environment.plist") (goto-char (point-min)) (setq start (search-forward "\n")) (search-forward "") (beginning-of-line) (delete-region start (point)) (while list (setq pair (split-string (car list) "=") list (cdr list)) (setq key (nth 0 pair) value (nth 1 pair)) (insert " " key "\n") (insert " " value "\n") ;; Enable this variable in launchd (setq command (format "launchctl setenv %s \"%s\"" key value)) (shell-command command)) ;; Save the buffer. (save-buffer))) 

NOTA: Esta solución es una amalgama de las que vienen antes de que yo agregue la mía, particularmente la ofrecida por Matt Curtis, pero deliberadamente he intentado mantener mi plataforma de contenido ~/.bash_profile independiente y establecer el entorno de lanzamiento (una instalación única de Mac) ) en un script separado.

Otra solución gratuita, opensource, Mac OSX Mountain Lion (10.8) panel de preferencia / environment.plist es EnvPane .

El código fuente de EnvPane está disponible en Github . EnvPane parece que tiene características similares a RCEnvironment , sin embargo, parece que puede actualizar sus variables almacenadas al instante, es decir, sin la necesidad de reiniciar o iniciar sesión, lo cual es bienvenido.

Según lo indicado por el desarrollador:

EnvPane es un panel de preferencias para Mac OS X 10.8 (Mountain Lion) que le permite establecer variables de entorno para todos los progtwigs tanto en sesiones gráficas como terminales. No solo restaura el soporte para ~ / .MacOSX / environment.plist en Mountain Lion, sino que también publica sus cambios en el entorno de inmediato, sin la necesidad de cerrar sesión y volver a iniciar sesión.

EnvPane incluye (e instala automáticamente) un agente de lanzamiento que se ejecuta 1) antes del inicio de sesión y 2) cada vez que cambia ~ / .MacOSX / environment.plist. El agente lee ~ / .MacOSX / environment.plist y exporta las variables de entorno de ese archivo a la instancia de inicio del usuario actual a través de la misma API que es utilizada por launchctl setenv y launchctl unsetenv.

Descargo de responsabilidad: no estoy relacionado con el desarrollador o su proyecto.

PD: me gusta el nombre (suena como “Finaliza el dolor”).

¡En Mountain Lion, todas las /etc/launchd.conf /etc/paths y /etc/launchd.conf no tienen ningún efecto!

Los foros de desarrolladores de Apple dicen:

“Cambie Info.plist del .app mismo para que contenga un diccionario” LSEnvironment “con las variables de entorno que desee.

~ / .MacOSX / environment.plist ya no es compatible. ”

Así que Info.plist directamente el Info.plist la aplicación (haga clic con el botón derecho en “AppName.app” (en este caso SourceTree) y luego ” Show package contents “)

Mostrar el contenido del paquete

y agregó un nuevo par clave / dict llamado:

 LSEnvironment  PATH /Users/flori/.rvm/gems/ruby-1.9.3-p362/bin:/Users/flori/.rvm/gems/ruby-1.9.3-p362@global/bin:/Users/flori/.rvm/rubies/ruby-1.9.3-p326/bin:/Users/flori/.rvm/bin:/usr/bin:/bin:/usr/sbin:/sbin:/usr/local/bin:  

(ver: LaunchServicesKeys Documentation at Apple )

enter image description here

ahora la aplicación (en mi caso SourceTree) usa la ruta dada y funciona con git 1.9.3 🙂

PD: por supuesto, tiene que ajustar la entrada de ruta a sus necesidades específicas de ruta.

Si bien las respuestas aquí no son “incorrectas”, agregaré otra: nunca realice cambios en las variables de entorno en OS X que afecten “todos los procesos”, o incluso, fuera del intérprete de comandos, para todos los procesos ejecutados interactivamente por un usuario determinado.

En mi experiencia, los cambios globales en variables de entorno como PATH para todos los procesos tienen incluso más probabilidades de romper cosas en OS X que en Windows. Por esta razón, muchas aplicaciones OS X y otro software (incluidos, tal vez especialmente, los componentes del sistema operativo) confían en las herramientas de línea de comandos de UNIX y asumen el comportamiento de las versiones de estas herramientas proporcionadas con el sistema, y no necesariamente utiliza rutas absolutas al hacerlo (los comentarios similares se aplican a bibliotecas cargadas dinámicamente y variables de entorno DYLD_ *). Considere, por ejemplo, que las respuestas mejor calificadas para varias preguntas sobre el Desbordamiento de stack sobre cómo reemplazar las versiones de intérpretes provistas por OS X, como Python y Ruby, generalmente dicen “no hagas esto”.

OS X no es realmente diferente a otros sistemas operativos tipo UNIX (p. Ej., Linux, FreeBSD y Solaris) a este respecto; la razón más probable por la que Apple no proporciona una manera fácil de hacerlo es porque rompe las cosas . En la medida en que Windows no es tan propenso a estos problemas, se debe a dos cosas: (1) el software de Windows no tiende a depender de las herramientas de línea de comandos en la medida en que el software UNIX lo hace, y (2) Microsoft ha tenido un historial tan extenso de “DLL hell” y problemas de seguridad causados ​​por cambios que afectan a todos los procesos que han cambiado el comportamiento de la carga dinámica en las versiones más recientes de Windows para limitar el impacto de las opciones de configuración “globales” como PATH.

“Lame” o no, tendrás un sistema mucho más estable si restringes esos cambios a ámbitos más pequeños.

A veces, todas las respuestas anteriores simplemente no funcionan. Si desea tener acceso a una variable del sistema (como M2_HOME ) en Eclipse o en IntelliJ IDEA, lo único que funciona para mí en este caso es:

Primero (paso 1) edite /etc/launchd.conf para contener una línea como esta: “setenv VAR value” y luego (paso 2) reiniciar.

Simplemente modificar .bash_profile no funcionará porque en OS X las aplicaciones no se inician como en otros Unix’es; ellos no heredan las variables de shell de los padres. Todas las demás modificaciones no funcionarán por una razón que desconozco. Tal vez alguien más pueda aclarar sobre esto.

Después de buscar el panel de preferencias Variables de entorno y descubrir que el enlace está roto y una búsqueda en el sitio de Apple parece indicar que se han olvidado de él … Empecé a seguir el camino del elusivo proceso de lanzamiento.

En mi sistema (Mac OS X 10.6.8) parece que las variables definidas en environment.plist se exportan de manera confiable a las aplicaciones lanzadas desde Spotlight (a través de launchd). Mi problema es que esos vars no se están exportando a nuevas sesiones bash en Terminal. Es decir, tengo el problema opuesto como se muestra aquí.

NOTA: environment.plist se parece a JSON, no XML, como se describió anteriormente

Pude conseguir que las aplicaciones de Spotlight vieran los vars editando ~ / MacOSX / environment.plist y pude forzar los mismos vars en una nueva sesión de Terminal agregando lo siguiente a mi archivo .profile:

 eval $(launchctl export) 

Actualización (2017-08-04)

A partir de (al menos) macOS 10.12.6 (Sierra), este método parece haber dejado de funcionar para Apache httpd (tanto para el system como para la opción de user de launchctl config ). Otros progtwigs no parecen verse afectados. Es concebible que esto sea un error en httpd.

Respuesta original

Esto se refiere a OS X 10.10+ (10.11+ específicamente debido al modo sin raíz donde /usr/bin ya no es grabable).

He leído en varios lugares que el uso de launchctl setenv PATH para establecer la variable PATH no funciona debido a un error en OS X (lo que parece cierto por experiencia personal). Descubrí que hay otra manera en que se puede configurar PATH para aplicaciones que no se iniciaron desde el shell :

 sudo launchctl config user path  

Esta opción está documentada en la página man de launchctl:

sistema de configuración | valor del parámetro de usuario

Establece la información de configuración persistente para dominios launchd (8). Solo el dominio del sistema y los dominios del usuario pueden ser configurados. La ubicación del almacenamiento persistente es un detalle de implementación, y los cambios en ese almacenamiento solo deben realizarse a través de este subcomando. Se requiere reiniciar para que los cambios realizados a través de este subcomando entren en vigencia.

[…]

camino

Establece la variable de entorno PATH para todos los servicios dentro del dominio de destino en el valor de cadena. El valor de cadena debe ajustarse al formato descrito para la variable de entorno PATH en environ (7). Tenga en cuenta que si un servicio especifica su propia RUTA, la variable de entorno específica del servicio tendrá prioridad.

NOTA: Esta función no se puede usar para establecer variables de entorno generales para todos los servicios dentro del dominio. Tiene un scope intencional para la variable de entorno PATH y nada más por razones de seguridad.

He confirmado que esto funciona con una aplicación GUI iniciada desde Finder (que usa getenv para obtener PATH). Tenga en cuenta que solo tiene que hacer esto una vez y el cambio será persistente a través de reinicios.

Cualquiera de los archivos de inicio de Bash: ~/.bashrc , ~/.bash_profile , ~/.profile . También hay algún tipo de archivo raro llamado ~/.MacOSX/environment.plist para variables de entorno en aplicaciones GUI.

Al igual que la respuesta dada por Matt Curtis, establezco variables de entorno a través de launchctl, pero la envuelvo en una función llamada export, de modo que cada vez que exporto una variable como normal en mi .bash_profile, también se establece mediante launchctl. Esto es lo que hago:

  1. Mi .bash_profile consiste únicamente de una línea, (Esto es solo preferencia personal).

     source .bashrc 
  2. Mi .bashrc tiene esto:

     function export() { builtin export "$@" if [[ ${#@} -eq 1 && "${@//[^=]/}" ]] then launchctl setenv "${@%%=*}" "${@#*=}" elif [[ ! "${@//[^ ]/}" ]] then launchctl setenv "${@}" "${!@}" fi } export -f export 
  3. Lo anterior sobrecargará la “exportación” Bash incorporada y exportará todo normalmente (¡notarás que exporto “exportar” con ella!), Luego los configurará correctamente para los entornos de la aplicación OS X a través de launchctl, ya sea que uses cualquiera de los siguientes:

     export LC_CTYPE=en_US.UTF-8 # ~$ launchctl getenv LC_CTYPE # en_US.UTF-8 PATH="/usr/local/bin:${PATH}" PATH="/usr/local/opt/coreutils/libexec/gnubin:${PATH}" export PATH # ~$ launchctl getenv PATH # /usr/local/opt/coreutils/libexec/gnubin:/usr/local/bin:/usr/bin:/bin:/usr/sbin:/sbin:/usr/local/bin export CXX_FLAGS="-mmacosx-version-min=10.9" # ~$ launchctl getenv CXX_FLAGS # -mmacosx-version-min=10.9 
  4. De esta forma, no tengo que enviar todas las variables a launchctl todo el tiempo, y puedo simplemente configurar mi .bash_profile / .bashrc configurado de la manera que quiero. Abra una ventana de terminal, revise las variables de entorno que le interesan con launchctl getenv myVar , cambie algo en su launchctl getenv myVar / .bashrc, cierre la ventana del terminal y vuelva a abrirlo, compruebe la variable nuevamente con launchctl y voilá, ha cambiado

  5. Una vez más, al igual que las otras soluciones para el mundo posterior al Mountain Lion, para que las nuevas variables de entorno estén disponibles para las aplicaciones, debe iniciarlas o relanzarlas después del cambio.

Here is a very simple way to do what you want. In my case, it was getting gradle to work (for Android Studio )

  • Open up Terminal.
  • Run the following command:

    sudo nano /etc/paths or sudo vim /etc/paths

  • Enter your password, when prompted.

  • Go to the bottom of the file, and enter the path you wish to add.
  • Hit control-x to quit.
  • Enter ‘Y’ to save the modified buffer.
  • Open a new terminal window then type:

    echo $PATH

You should see the new path appended to the end of the PATH

I got these details from this post:

http://architectryan.com/2012/10/02/add-to-the-path-on-mac-os-x-mountain-lion/#.UkED3rxPp3Q

I hope that can help someone else

I think the OP is looking for a simple, Windows-like solution.

Aqui tienes:

http://www.apple.com/downloads/macosx/system_disk_utilities/environmentvariablepreferencepane.html

To be concise and clear about what each file is intended for

  • ~/.profile is sourced every time Terminal.app is launched
  • ~/.bashrc is where “traditionally” all the export statements for Bash environment are set
  • /etc/paths is the main file in Mac OS that contains the list of default paths for building the PATH environment variable for all users
  • /etc/paths.d/ contains files that hold additional search paths

Non-terminal programs don’t inherit the system wide PATH and MANPATH variables that your terminal does! To set environment for all processes launched by a specific user, thus making environment variables available to Mac OS X GUI applications, those variables must be defined in your ~/.MacOSX/environment.plist (Apple Technical Q&A QA1067)

Use the following command line to synchronize your environment.plist with /etc/paths :

 defaults write $HOME/.MacOSX/environment PATH "$(tr '\n' ':'  

the $PATH variable is also subject to path_helper , which in turn makes use of the /etc/paths file and files in /etc/paths.d .

A more thorough description can be found here: http://hea-www.harvard.edu/~fine/OSX/path_helper.html

Setup your PATH environment variable on Mac OS

Open the Terminal program (this is in your Applications/Utilites folder by default). Run the following command touch ~/.bash_profile; open ~/.bash_profile This will open the file in the your default text editor.

For ANDROID SDK as example :

You need to add the path to your Android SDK platform-tools and tools directory. In my example I will use “/Development/android-sdk-macosx” as the directory the SDK is installed in. Add the following line:

 export PATH=${PATH}:/Development/android-sdk-macosx/platform-tools:/Development/android-sdk-macosx/tools 

Save the file and quit the text editor. Execute your .bash_profile to update your PATH.

 source ~/.bash_profile 

Now everytime you open the Terminal program you PATH will included the Android SDK.

It’s simple:

Edit ~/.profile and put your variables as follow

$ vim ~/.profile

In file put:

MY_ENV_VAR=value

  1. Save ( :wq )

  2. Restart the terminal (Quit and open it again)

  3. Make sure that`s all be fine:

$ echo $MY_ENV_VAR

$ value


For a single user modification, use ~/.profile of the ones you listed. The following link explains when the different files are read by Bash.

http://telin.ugent.be/~slippens/drupal/bashrc_and_others

If you want to set the environment variable for gui applications you need the ~/.MacOSX/environment.plist file

There are two type of shells at play here.

  • Non-Login: .bashrc is reloaded every time you start a new copy of bash
  • Login: The .profile is loaded only when you either login, or explicitly tell bash to load it and use it as a login shell.

Its important to understand here that with bash .bashrc is only read by a shell that’s both interactive and non-login, and you will find that people often load .bashrc in .bash_profile to overcome this limitation.

Now that you have the basic understanding, lets move on to how i would advice you to set it up.

  • .profile: create it non-existing. Put your PATH setup in there.
  • .bashrc: create if non-existing. Put all your Aliases and Custom method in there.
  • .bash_profile: create if non-existing. Put the following in there.

.bash_file:

 #!/bin/bash source ~/.profile # Get the PATH settings source ~/.bashrc # Get Aliases and Functions # 

Login Shells

 /etc/profile 

The shell first executes the commands in /etc/profile. A user working with root privileges can set up this file to establish systemwide default characteristics for users running bash.

 .bash_profile .bash_login .profile 

Next the shell looks for ~/.bash_profile, ~/.bash_login, and ~/.profile (~/ is short- hand for your home directory), in that order, executing the commands in the first of these files it finds. You can put commands in one of these files to override the defaults set in /etc/profile. A shell running on a virtual terminal does not execute commands in these files.

 .bash_logout 

When you log out, bash executes commands in the ~/.bash_logout file. This file often holds commands that clean up after a session, such as those that remove temporary files.

Interactive Nonlogin Shells

 /etc/bashrc 

Although not called by bash directly, many ~/.bashrc files call /etc/bashrc. This setup allows a user working with root privileges to establish systemwide default characteristics for nonlogin bash shells.

 .bashrc 

An interactive nonlogin shell executes commands in the ~/.bashrc file. Typically a startup file for a login shell, such as .bash_profile, runs this file, so both login and nonlogin shells run the commands in .bashrc.

Because commands in .bashrc may be executed many times, and because subshells inherit exported variables, it is a good idea to put commands that add to existing variables in the .bash_profile file.

/etc/launchd.conf is not used in Yosemite, El Capitain, or (High) Sierra

From the launchctl man page:

 /etc/launchd.conf file is no longer consulted for subcommands to run during early boot time; this functionality was removed for security considerations. 

The method described in this Ask Different answer works for me (after a reboot): applications launched from the Dock or from Spotlight inherit environment variables that I set in ~/Library/LaunchAgents/my.startup.plist . (In my case, I needed to set LANG , to en_US.UTF-8 , for a Sublime Text plugin.)

Well, I’m unsure about the /etc/paths and ~/.MacOSX/environment.plist files. Those are new.

But with Bash, you should know that .bashrc is executed with every new shell invocation and .bash_profile is only executed once at startup.

I don’t know how often this is with Mac OS X. I think the distinction has broken down with the window system launching everything.

Personally, I eliminate the confusion by creating a .bashrc file with everything I need and then do:

 ln -s .bashrc .bash_profile 

One thing to note in addition to the approaches suggested is that, in OS X 10.5 (Leopard) at least, the variables set in launchd.conf will be merged with the settings made in .profile . I suppose this is likely to be valid for the settings in ~/.MacOSX/environment.plist too, but I haven’t verified.

For Bash, try adding your environment variables to the file /etc/profile to make them available for all users. No need to reboot, just start a new Terminal session.

It’s quite simple, edit .profile (vi, nano, sublimeText or other text editor) file, you can found it at ~/ directory (user directory) and set like this :

export MY_VAR=[your value here]

exemple with java home :

export JAVA_HOME=/Library/Java/JavaVirtualMachines/current

save it and return to the terminal.

You can reload it with :

source .profile or close / open your terminal window.

Just did this really easy and quick. First create a ~/.bash_profile from terminal:

 touch .bash_profile 

entonces

 open -a TextEdit.app .bash_profile 

añadir

 export TOMCAT_HOME=/Library/Tomcat/Home 

save documement and you are done.