Instale hoje o Darling (Alpha) - emulador do Darwin/Mac OS X!

[Nosferatu Arucard]

Para quem não saiba, o Darling é uma espécie de Wine do qual permite teoricamente executar programas e aplicações do sistema operativo Mac OS X em sistemas Linux.  

http://www.darlinghq.org

Na prática é um software ainda em estado alfa que ainda está relativamente verde, com reduzida compatibilidade com os programas do sistema operativo da Apple e companhia.
Comparado com o Wine que já é um software apto para correr muito software do Windows, e que teve que implementar do zero todas as interfaces de programação, o Darling mal nasceu, mas têm uma vantagem esmagadora em relação ao Wine, é que as principais API presentes no Mac OS X foram implementadas pelo projecto GNU-Step.

No entanto o autor do projecto Darling ainda teve que enviar patches para corrigir bugs e funções não-implementadas   no GNU-Step, desviando o ênfase da sua parte que era implementar o userland do kernel Darwin sobre o Linux, o que é um módulo do kernel Linux que implementa o Mach API do qual o Cocoa e o Carbon API correm sobre ele. O módulo BSD já existe no mundo Linux, portanto felizmente é menos um factor de carga de trabalhos.
Portanto o Cocoa API está presente no GNU-Step, mas o Carbon API ficou a cargo do projecto Darling. (É uma herança do Mac OS 9 que migrou para as primeiras edições do Mac OS X quando suportava a arquitectura PowerPC. Apesar disso, o Carbon API está presente nas versões Intel do Mac OS X, sendo usado em softwares que ainda utilizam as antigas API, mas não serão elegíveis a longo prazo esta API para programas futuros.)

Para quem quiser experimentar o Darling, deverá ter o Ubuntu 13.04 a funcionar (recomenda-se a versão de 64-bits).
(Pode usar o Gentoo ou o Arch visto serem mais adequados para instalar softwares experimentais).
Em máquinas Ubuntu, o suporte multiarch pode provocar quebras nas dependências, portanto deve ignorar os passos relativos a esta fase até que sejam corrigidos.

1.1 Instalação das dependências primárias.
sudo apt-get install git cmake clang nasm g++

1.2 Instalação das bibliotecas primárias.
sudo apt-get install libxml2-dev libgnutls-dev libicu-dev libcairo-dev \
                    libjpeg-dev libpng-dev libtiff-dev libbsd-dev libudev-dev \
                    liblcms-dev libkqueue-dev libssl-dev libbz2-dev uuid-dev \
                    libncurses-dev libxrandr-dev

1.3 Suporte multiarch (Sujeito a falhas!)
sudo apt-get install g++-multilib
sudo dpkg --add-architecture i386
echo "/usr/lib/i386-linux-gnu" | sudo tee /etc/ld.so.conf.d/zz_i386.conf
sudo ldconfig

Quando ultrapassar esta fase, vamos instalar a partir do código-fonte o GNU-Step.
2.1 GNU-Step Make
git clone https://github.com/gnustep/gnustep-make.git
cd gnustep-make
CC=clang CXX=clang++ ./configure
sudo make install

2.2 GNU-Step Libojec2 (Runtime Objective-C, sendo a principal linguagem de programação do Mac OS X)
git clone https://github.com/gnustep/gnustep-libobjc2.git
cd gnustep-libobjc2
OBJCFLAGS=-fblocks CC=clang CXX=clang++ cmake .
rm GNUmakefile
make
sudo make install

2.2.1 Suporte multiarch Libojec2 (Sujeito a falhas!)
git clean -fdx
OBJCFLAGS="-fblocks" CFLAGS=-m32 ASMFLAGS=-m32 CC=clang CXX=clang++ cmake . -DGNUSTEP_INSTALL_TYPE=NONE -DLIB_INSTALL_PATH=/usr/lib/i386-linux-gnu
make
sudo make install

2.3 GNU-Step Base (Contêm as frameworks do Cocoa API)
git clone https://github.com/gnustep/gnustep-base.git
cd gnustep-base
OBJCFLAGS=-fblocks CC=clang CXX=clang++ ./configure
make
sudo make install

2.3.1 Suporte multiarch Base (Incompleto)
sudo apt-get install libffi6:i386 libxml2:i386 libgnutls26:i386
sudo ln -s libffi.so.6 /usr/lib/i386-linux-gnu/libffi.so
sudo ln -s libxml2.so.2 /usr/lib/i386-linux-gnu/libxml2.so
sudo ln -s libgcrypt.so.11 /lib/i386-linux-gnu/libgcrypt.so

2.4 GNU-Step GUI (Framework gráfica)
git clone https://github.com/gnustep/gnustep-gui.git
cd gnustep-gui
OBJCFLAGS=-fblocks CC=clang CXX=clang++ ./configure
make
sudo make install

2.5 GNU-Step Opal (Implementação do Quartz2D sobre o Cairo)
git clone https://github.com/gnustep/gnustep-opal.git
cd gnustep-opal
OBJCFLAGS=-fblocks CC=clang CXX=clang++ make
sudo make install

2.6 GNU-Step Corebase (Implementação do CoreFoundation, incluindo os patches do Darling)
git clone https://github.com/LubosD/gnustep-corebase.git
cd gnustep-corebase
OBJCFLAGS=-fblocks CC=clang CXX=clang++ ./configure
make
sudo make install

Se sobreviveu a esta maratona de compilar e instalar pacotes de software, então os meus parabéns!
Só resta instalar o Darling!  

3. Instalação do Darling (Finalmente!)
git clone --recursive git://github.com/LubosD/darling.git
cd darling
CC=clang CXX=clang++ cmake .
make
sudo make install

Por fim, deve correr o programa ldconfig para completar a configuração do sistema.

Para usar o Darling, basta copiar o ficheiro app para a pasta Applications e abrir uma linha de comando no Terminal:
dyld <os-x app> <argumentos>
O log aparecerá nessa janela, e caso funcione terá a sua primeira aplicação do Mac OS X a correr no Ubuntu  

Em sistemas multiarch deverá usar os comandos dyld32 ou dyld64 respectivamente.

[garfo]

Muito "Hacker" pra mim. Até terminar de compilar isso tudo eu já comprei meu iMac e fui pras Bahamas... 

[Nosferatu Arucard]

Isto e´ a instalaç˜ao de software em Linux ao estilo antigo. 
Assim que o Darling evoluir e´ bem provavel que bastara´ um
sudo apt-get install darling
e responder a "y" para dependencias cruzadas, que ao fim de um ou dois minutos ja´ estara´ a correr programas do Mac OS X no Ubuntu.
Tambem pode instalar o Wine a partir do codigo-fonte, so´ que demora uma hora para compilar e instalar, o Darling ocorre precisamente o mesmo. 

[Nosferatu Arucard]

Uma pequena actualização do projecto Darling: Já estão disponíveis para o sistema operativo Ubuntu uma PPA com os pacotes compilados do Darling, no entanto alertamos que a versão 0.1 do Darling é ainda muito, muito verde com uma reduzida compatibilidade de aplicações para o Mac OS X a correr no Ubuntu.  
Por agora este PPA, embora sincronizado com o git oficial do Darling, suporta uma pequena parte do framework GNU-Step (que serve de base do Cocoa API) e do Carbon API. Por agora, este PPA não inclui o darling-installer e o darling-dmg que são respectivamente o instalador de pacotes PKG herdado do BSD  , e um driver do FUSE para montar imagens de discos com extensão dmg, que são basicamente um disco virtual com o sistema de ficheiros HFS.
É pena a não inclusão (por agora  ) destes utilitários (ainda no estágio inicial), porque são necessários estes dois componentes para instalar software comercial não agregada ao Mac App Store.

Para instalar o referido software, terá que adicionar o repositório do Darling:
sudo apt-add-repository ppa:thopiekar/darling

Actualize o sistema com dois comandos:
sudo apt-get update
sudo apt-get upgrade

Por fim, instale o software com este comando:
sudo apt-get install darling

E efectue um fetching das bibliotecas com isto:
ldconfig

Surpreendentemente, uma instalação limpa do Darling ocupa apenas 25 Mb, não contando com dependências do sistema operativo.
Ao contrário do Wine, não existe aqui nenhum "MacPrefix", pois sendo o Mac OS X um sistema BSD, a mesma estrutura de ficheiros e permissões do Ubuntu é-lhe inteligível, e as bibliotecas são instalados nos directórios de sistema.
(Mas seria adequado pelo menos uma pasta para as Applications dentro da pasta de usuário para manter a coerência da simulação do Mac OS X no Ubuntu).

Não garanto que este v.0.1 alpha sirva realisticamente para testar software, mas para os mais corajosos, basta tirar um programa típico do Mac OS X (uma pasta com extensão app  ) para o Ubuntu e verificar se corre, ou dará erro:

dyld <nome da app>

No meu exemplo, eu experimentei o The Unarchiver que ainda não funciona bem, e deu-me o seguinte log:
(Tive que fazer um hack sugerido pelo loader antes de executar...)
$ sudo sysctl -w vm.mmap_min_addr="0x1000"
$ dyld The\ Unarchiver.app/

2013-08-28 14:29:20.097 The Unarchiver[3951] File NSBundle.m: 880. In +[NSBundle(Private) _addFrameworkFromClass:] Could not find framework UniversalDetector in any standard location
dyld: Cannot execute binary file: Symbol not found: _kLSItemQuarantineProperties

(Um dos bugs é a falta de uma pasta Aplicações de modo a que os frameworks internos sejam devidamente executados, outro é a falta do Java para o GNUStep  )

De qualquer forma foi o primeiro passo para o Linux poder correr programas do Mac OS X!
Para um Alpha não foi nada mal, o Wine só conseguiu correr os primeiros programas ao fim de um ano de desenvolvimento!

[Nosferatu Arucard]

Ao fim de vários meses de experiências e testes, foi lançado o segundo alpha do Darling  , e o PPA oficioso já contêm agora todos os recursos base do software, mas para quem usou o primeiro alpha será necessário reconfigurar os repositórios... 

Novidades da versão 0.2
- Inclusão do toolkit Qt para a implementação do framework AppKit (sem isso, nem 99% dos programas do Mac OS X funcionam!)
- Correcção da implementação do Core Fundation e Core Graphics.
- Correcção de bugs.
- Montador de imagens DMG (quase todo o software para OS X é fornecido em imagens DMG, mesmo dentro de CD  )
- Melhorias (ligeiras) no instalador de pacotes PKG (ainda não muito funcional  ), o que impede a instalação de programas em pacotes binários (O PKG é um género de DEB para sistemas BSD e derivados).
- Afinamentos ligeiros no Mach API e BSD API.

Também o projecto ganhou um site oficial
www.darlinghq.org
(Quase similar ao site oficial do Wine! Aliás, o Darling é um "Wine" do OS X!)

Para instalar, será necessário definir três repositórios para instalar o programa:
$ sudo add-apt-repository ppa:thopiekar/darling
$ sudo add-apt-repository ppa:thopiekar/gnustep
$ sudo add-apt-repository ppa:thopiekar/llvm

Actualizar os repositórios, e instalar:
$ sudo apt-get update
$ sudo apt-get install darling
$ sudo apt-get install darling-dmg
$ sudo apt-get install darling-installer

Apesar do Darling ser um programa similar ao Wine, existe enormes diferenças...
- Não existe um MacPrefix, os programas são instalados no sistema de ficheiros do Ubuntu como qualquer programa BSD/Linux.
Na realidade, todo o programa para OS X entenderá o sistema de ficheiros nativo do Ubuntu directamente, pois o Mac OS X e o Linux são sistemas UNIX, portanto todas as permissões, ficheiros de sistema, bibliotecas e ficheiros de utilizador são entendidos de forma igual.
- O OS X utiliza duas API de modo núcleo, o Mach API para operações internas com o hardware do qual não têm similaridade com o kernel Linux (O GNU/HURD é um sistema baseado no kernel Mach), embora felizmente só seja usada por drivers, e algumas sub-rotinas de sistemas de controlo do qual a esmagadora maioria dos programas não usam, e o BSD API que é 99% compatível com o Linux, exigindo apenas uma pequena biblioteca de compatibilidade (libbsd). O Darling mal suporta a emulação do Mach, embora não seja realisticamente um obstáculo, pois para a maioria das aplicações com interesse para este emulador, mal usará o Mach API.
- Como os executáveis do OS X são Mach-O binary (e não ELF), o Darling utiliza um loader (dyld) para os carregar e iniciar na memória. Depois de inicializados, comportam-se como qualquer programa UNIX que o Linux entende sem conversões.
- O Darling utiliza o GNU-Step que é uma implementação livre do Cocoa API, embora seja modificada pelo projecto Darling (usa o Qt para o AppKit), para que programas que usem a interface gráfica funcionem. Ao contrário do Wine que utiliza um toolkit de raíz sobre o X11 e necessite de tradução para qualquer função, o Darling utiliza toolkits nativos (Qt/GNU-Step) do X11, e as aplicações mal necessitam de tradução para além dos frameworks.
- Embora esteja em fase alpha, o Carbon API é (muito) parcialmente suportado. Este framework foi criado pela Apple para portar software do Mac OS Classic para o OS X, e infelizmente não existe um projecto open-source que o tivesse implementado de antemão.
- Ao  contrário do Windows, o OS X utiliza as mesmas bibliotecas gráficas e multimédia que o Linux: o OpenGL, o OpenAL, o OpenCL.
Portanto, o Darling não precisa de implementar funções de baixo nível (como o Wine que teve que implementar o DirectX, .NET, etc) para que os jogos do OS X funcionem no Linux.
- Os programas do OS X são na realidade uma pasta com extensão *.app, portanto para (tentar) usar o programa, arranje um programa para OS X  simples e tente executá-lo ao abrir o Terminal e usar o dyld para abrir a aplicação:
$ dyld programa.app

Por agora, a compatibilidade é ainda muito reduzida, por agora vou experimentar alguns programas e depois publico a experiência. 

[Turritopsis nutricula]

Espero que isso aí se desenvolva mais rápido que o Wine ou o Mono. O Wine mesmo estando avançado, não quebra muito o galho.
O negócio é programa nativo até que um dia o Wine funcione direito. Espero estar vivo pra ver isso se concretizando.

[Tota]

Espero que isso aí se desenvolva mais rápido que o Wine ou o Mono. O Wine mesmo estando avançado, não quebra muito o galho.

Com o exército de advogados e patentes que a Apple tem? Esqueça.

O OpenStep patina a anos. Ele foi criado na Next pelo Steve Jobs e abandonado a propria sorte quando ele voltou pra Apple.

Isto aí é como chutar "cachorro morto".

Ou você acredita que a Apple vai abrir mão dos 5 bi de dolares faturados pela applestore, só para deixar uma meia duzia de entusiastas baixar e instalar dmg's nas maquinas sem passar pela loja?

Usei o OpenStep lá pelos idos de 90, estamos em 2014, ou seja, 24 anos depois e os caras estão em versão alfa.

[Nosferatu Arucard]

O foco do Darling e´ para programas que nao estejam distribuidos exclusivamente pela App Store: AutoCad, Maya, Photoshop, ...
Ou mesmo para portar software do OS X para Linux.
De qualquer forma, ja´ era mais que tempo para alguem implementar uma biblioteca de compatibilidade do OS X para Linux, embora o Wine tenha maior usuabilidade por causa da esmagadora maioria do software usar o Win32 API.

[Tota]

Concordo com o "portar aplicativos do OsX para o Linux" porém o que é feito é o inverso (o fotoboot do mac é o cheese em roupa nova)

Já o uso de autocad, maya, photoshop não justifica o esforço. Eles custam o mesmo ou mais que uma maquina Apple nova. Quem precisa e usa software de US$ 5,000.00 compra uma máquina de US$ 5,000.00 sem o menor sofrimento. Quem deseja economizar usa Windows.

Eu pessoalmente jamais autorizaria o uso de autocad e assemelhados na empresa usando emuladores. O custo do suporte não compensa.

É um projeto interessante, como o wine, o jailbreak para IOs, o cedega, e tantos outros. Serve bem a hobbistas e entusiastas.

Ideias e projetos sempre são bem vindos, mas precisam ser práticos, o que neste caso vai demorar, principalmente pela nova implementação da interface gráfica da Apple nos próximos SO (cocoa touch) abandonando de vez o X11 e redormulando totalmente o xcode

Será uma briga sem fim, como no wine

[Nosferatu Arucard]

Embora nao seja oficialmente suportado pela Adobe, conheço algumas pequenas empresas que usam o Photoshop a correr no Linux com o Wine, visto que usavam muito software opensource e so´ precisavam de um ou outro programa para Windows, e como o Wine funcionava, adoptaram esta configuraçao.

O autor do Darling (LubosD) aparenta ser muito realista, e selectivo na escolha dos seus colaboradores, pois embora tenha recebido muitas propostas algo irrealistas como a emulaçao PowerPC (numa altura em o suporte x86 e´ diminuto), ou o suporte ao iOS (que eventualmente admite). Em relaçao ao GNU-Step que utiliza parte dele, LubosD ja´ optou por utilizar o toolkit Qt 4/5 para implementar parte das frameworks que o GNU-Step mal suporta, pois ate´ a implementaçao do GUI ja´ esta´ obsoleta.
Basicamente e´ um dos objectivos centrais do Darling: migrar do GNU-Step completo para um modificado complementado com o Qt/QML. Isto tornaria as aplicaçoes mais nativas em termos de apresentaçao no Ubuntu, mesmo usando o Cocoa API.

Outro objectivo a prazo e´ o suporte ao Carbon API para a execuçao de aplicaçoes mais antigas, que ate´ as ultimas versoes do OS X ja´ nao suportam ou as bibliotecas encontram-se depreciadas. O Darling suporta ainda parte do Carbon, mas ainda nao e´ suficiente para a execuçao de aplicaçoes (O jogo World of Warcraft foi escolhido como modelo para a implementaçao do Carbon API no Darling!)

De qualquer forma, eu gostaria que a breve prazo o Darling ja´ corresse alguns freewares, ou mesmo o Steam/Origin Client pois seria engraçado correr a versao Linux, Windows e OS X do Steam no Desktop Ubuntu para comparaçao. 

[Nosferatu Arucard]

Instruções actualizadas!

O darling é um programa que exige uma dose de aventura para instalar, porque está em desenvolvimento activo, e por vezes pode mudar do nada as dependências para a instalação!

Por agora, a única forma realista para instalar este programa é através da compilação e instalação à unha, como nos bons e velhos tempos do Linux...


Para instalar como pelo menos o suporte alpha às aplicações com interface gráfica do Mac OS X (Ainda não pensem algo mais complicado que uma simples janela de pop-up!), e suporte áudio, deve ter a versão de 64-bit do Ubuntu.
Por vezes, usar uma versão LTS ajuda, mas se usar o 16.10, terá que aplicar alguns hacks, porque os autores ainda não actualizaram os scripts de compilação.

Antes de tudo, instale os pacotes:
$ sudo apt-get install cmake clang bison flex xz-utils libfuse-dev libxml2-dev libicu-dev libssl-dev libbz2-dev zlib1g-dev libudev-dev linux-headers-generic libaspell-dev libpulse-dev libasound2-dev libavresample-dev libavformat-dev libavcodec-dev libpng-dev libjpg-dev libcairo-dev

Pois o projecto Darling utiliza o compilador Clang em vez do GCC.

Agora clone o branch Appkit, usando o git:
git clone -b appkit --recursive https://github.com/darlinghq/darling.git
(Vai demorar um bom bocado!)

Depois aplique os seguintes comandos no Terminal

cd darling
mkdir -p build/x86-64
cd build/x86-64
cmake ../.. -DCMAKE_TOOLCHAIN_FILE=../../Toolchain-x86_64.cmake -DFRAMEWORK_COREAUDIO=ON -DFRAMEWORK_APPKIT=1
make
sudo make install

A compilação vai demorar um bom bocado, e mesmo que tenha o computador saído do forno, aguarde alguns minutos...

Ainda assim, como no meu caso, pode necessitar de corrigir os seguintes symlinks no código-fonte.
ln -s /usr/include/pngconf.h pngconf.h
ln -s /usr/include/pnglibconf.h pnglibconf.h
Nos directórios: ./darling/src/external/AppKit/Headers/Native e ./darling/src/external/CoreGraphics/Headers/Native

Por fim edite os ficheiros CMake.txt em ./darling/src/external/AppKit e ./darling/src/external/CoreGraphics
para trocar a linha:
target_link_libraries(AppKit CFF system ApplicationServices png12 aspell gif tiff jpeg X11 Xext Xrender fontconfig cairo)
por...
target_link_libraries(AppKit CFF system ApplicationServices png16 aspell gif tiff jpeg X11 Xext Xrender fontconfig cairo)

(Que é trocar a biblioteca png1.2 por png1.6, que não afecta o funcionamento do programa...)

Feito a compilação, e instalado o programa, falta compilar o módulo de kernel que emula o Mach:

cd ../../src/lkm
sudo ./dkms.sh

Por fim, instale o módulo, que deve ser feito cada vez que inicie sessão:

$ sudo modprobe darling-mach
$ sudo chmod a+rw /dev/mach

Agora, só falta iniciar o Mac OS X "virtual":
$ darling shell

Darling [/]$
Que é não é mais que um port do bash para Mac OS X a correr sobre o Ubuntu !!!

A instalação base cria um DPREFIX em ~/.darling, que contêm os ficheiros de sistema, incluindo vários ports de programas conhecidos no Ubuntu como o python, man, cp, ...
E também versões simplificadas do installer e hdiutil.

Podemos conferir a versão emulada pelo Darling
$ uname -a
Darwin hellsing 12.0.0 Darwin Kernel Version 12.0.0 x86_64

Os comandos internos são programas Linux nativos, pois por exemplo, o python:
$ file /usr/bin/python
/usr/bin/python: ELF 64-bit LSB shared object, x86-64, version 1 (SYSV), dynamically linked, not stripped


Indo ao site rudix, e transferindo a versão 10.12 do p7zip, podemos correr este compressor sem problemas.
E podemos ver que é um executável OS X nativo, pois:
$ file `which 7z`
Darling [~/Transferências]$ file `which 7z`
/usr/local/bin/7z: Mach-O 64-bit executable x86_64

E por agora termino aqui...

[Nosferatu Arucard]

Continuação das Instruções...

Prevê-se que dentro de poucas semanas vários dos branches do projecto Darling sejam unidos, dado que certos executáveis como o ruby para Mac OS X deve ser compilado como um executável mach-O nativo.
Isto significa que o AppKit e o Mach-O library deverão substituir o main branch, o que tornaria a maioria dos utilitários do Darling, de modo a substituir os executáveis ELF nativos para os Mach-O nativos do OS X.

Mas por agora, resta explicar como se instala o suporte de 32-bit (Mas não vai funcionar num sistema Ubuntu de 32-bit, pois não é suportado!), se bem que poucos programas para a plataforma Mac OS X existam para 32-bit-

Primeiro acrescente os pacotes de compatibilidade de 32-bit...

$ sudo apt-get install libc6-dev-i386 libudev-dev:i386 lib32stdc++-4.9-dev

E o resto é fácil de prosseguir...

cd darling
mkdir -p build/i386
cd build/i386
cmake ../.. -DCMAKE_TOOLCHAIN_FILE=../../Toolchain-x86.cmake -DFRAMEWORK_COREAUDIO=ON -DFRAMEWORK_APPKIT=1
make
sudo make install

O módulo de kernel é de apenas 64-bit, portanto não é necessário recompilar.

Programas PowerPC não são suportadas, embora os devs do Darling já aceitaram a sugestão como "enhancement", e isso só exigiria criar um Toolchain com as bibliotecas para a Arquitectura PowerPC, e instalar o qemu-ppc-static para funcionar.

Guia do Utilizador (alpha...)

Para iniciar o Darling, deve primeiro activar o módulo de kernel, pelo menos uma vez por login:
$ sudo modprobe darling-mach
$ sudo chmod a+rw /dev/mach

Por fim, inicie o Darling, que carrega a versão nativa do Mac OS X do bash:
$ darling shell

Após experimentar vários comandos que já encontra no Linux, no Darling (uns funcionais, outros desactivados/inexistentes/disfuncionais...), deve ter em conta que a directoria ~/.darling é interpretada dentro do OS X virtual como a root virtual.
Ao contrário do Wine, as associações entre directorias virtuais são idênticas aos sistemas Unix, pois podemos usar links simbólicos e usar os mesmos métodos e truques.
O suporte a programas com Interface Gráfica é experimental, pois os compiladores tendem a usar o framework Carbon que não foi ainda implementado, em vez de usar o AppKit "puro", e isso falha a sua execução no Darling.

É possível instalar o XCode no Darling, mas ficará limitado aos compiladores que operam na linha de comando...
(Alternativamente, pode instalar o Clang e o osx-cross com o XCode que cria os cross-compilers nativos para Linux, caso queira criar um ambiente de teste com programas simples, para depois testá-los no Darling. A última opção é mais segura.)

Ainda assim, o Darling implementou clones de dois programas exclusivos do Mac OS X: o installer e o hdiutil, que são versões muitos simplificadas do original...

Usando o Firefox (para Linux nativo, claro!), pode visitar o Rudix ou o MacPorts, e instalar (manualmente) vários pacotes PKG, que são para os sistemas BSD, os DEB para o Ubuntu e derivados.

Assumindo que possui o bash do Darling na directoria de Transferências, para instalar um pacote, faça:
$ installer -pkg <pacote> -target /
E depois digite o comando do programa.

Se tiver programas com problemas como não encontrar biblioteca x.so ou x.dylib, basta adicionar à variável de sistema DYLD_LIBRARY_PATH ou DYLD_FALLBACK_LIBRARY_PATH, a directoria correspondente.

Usando o hdiutil pode agregar imagens DMG, do qual utiliza o FUSE, e ficam montados em /Volumes.
$ hdiutil attach <image>
$ cd /Volumes/<image>

Como podem notar, a barreira de recriar um sistema BSD em Linux é muito menor que um sistema Windows.