1. Install Ubuntu On Windows Gnome
2. Install Gnome On Windows Subsystem For Linux
3. Install Windows On Gnome Boxes
4. Install Gnome On Windows 10 Ubuntu
5. Install Gnome On Windows
6. Install Gnome Ubuntu Windows 10
7. Install Gnome On Windows 10

A 64 bit installation of Manjaro running Gnome uses about 447MB of memory. Install a basic gnome environment sudo pacman -S gnome Optional: To install extra themes, games, and features sudo pacman -S gnome-extra Optional: Install and use GDM, the recommended display manager for gnome. GDM is installed as a dependency of gnome, to enable it. Installation GTK+ and gtkmm were designed to work well with Microsoft Windows, and the developers encourage its use on the win32 platform. However, Windows has no standard installation system for development libraries. Please see the Windows Installation page for Windows-specific installation instructions and notes.

• 2Desktop Environments
  • 2.2XFCE
  • 2.3KDE Plasma 5
  • 2.4Gnome 3
  • 2.5Budgie
  • 2.6Cinnamon
  • 2.7Deepin
  • 2.8Enlightenment
  • 2.9LXDE
  • 2.10LXQt
  • 2.11MATE
• 3Window Managers
  • 3.1Stacking Window Managers
    • 3.1.1Openbox
    • 3.1.2FluxBox
  • 3.2Tiling Window Managers

There are several Desktop Environments and Window Managers available for Manjaro, each with their own unique style, interface, and features. Furthermore, it is possible to install multiple environments if desired, which can be selected at the login screen at any time. Users are not restricted to whatever comes pre-installed with a particular flavour of Manjaro.

It is worth noting that a Desktop Environment(DE) is not a single entity; it is actually a collection of different components that work together. This commonly includes a:

• window manager to display, move and resize application windows
• file manager to visually browse, copy and access files, etc.
• background provider to display wallpapers, etc.
• panel to provide a menu and to display information such as the time
• settings/configuration manager to change the look of the environment

And so on. Most desktop environments will also come with their own preferred applications, in addition to various widgets, addons, and extensions to provide extra features. As such, upon entering the commands provided below in your terminal to download and install a desktop environment, you may be prompted to choose from a selection of components provided for it. To install a full desktop environment - complete with its own preferred file manager, applications, and so on

Where additional (and optional) extras for a desktop environment are available, the terminal commands to obtain these have also been provided.

Some important information about installing the Manjaro settings packages:

• The Manjaro settings packages contain the theming and settings to make the desktop the same as in the Manjaro ISOs
• They have the naming convention manjaro-<desktop>-settings i.e. manjaro-xfce-settings
• They share files so you can only have one at a time installed.
• If you are coming from gnome you must remove the meta package manjaro-gnome-assets before you can install the settings package for another desktop

The Risks of Using Multiple DEs

Installing multiple DEs is not without risks. Here are some things that can pop-up when running more than one DE:

• The settings packages overlap so you can only have one DE pre-configured with the Manjaro theming. The others will need to have the theming applied manually.
• You can end up with more than one instance of similar applications. For example, it is common to end up with 2 Bluetooth managers. It takes some tweaking to get a single manager working in multiple DEs
• Sometimes two different DEs will share the same configuration files causing strange things to happen, especially with theming

These risks are greatly reduced by using a different user account for each DE.

In summary, running multiple DEs is possible and a great way to enjoy Manjaro but it requires a willingness to troubleshoot and work through minor problems. If you are the type of person who wants everything to 'just work' out of the box, running multiple DEs might not be for you.

XFCE

XFCE is a lightweight and versatile desktop environment that utilises a classic drop-down or pop-up menu to access applications. It is also compatible with Compiz. A little time and effort will also be required to properly customise the desktop to suit personal taste. A 64 bit installation of Manjaro running XFCE uses about 390MB of memory. As of version 18, Manjaro has moved to the gtk3 version of XFCE.

Install a basic XFCE environment

Optional: Install and use LightDM, the recommended display manager for XFCE

edit /etc/lightdm/lightdm.conf, under [Seat:*] replace the greeter-session setting with greeter-session=lightdm-gtk-greeter

Optional: Install the Manjaro configuration and theming for XFCE

To configure LightDM to match the official iso replace the contents of /etc/lightdm/lightdm-gtk-greeter.conf with

Create a new user for the new desktop environment

KDE Plasma 5

The KDE community offers Plasma, a feature-rich and versatile desktop environment that provides several different styles of menu to access applications. Its default window manager is kwin, but is also compatible with Compiz. An excellent built-in interface to easily access and install new themes, widgets, etc, from the internet is also worth mentioning. A 64 bit installation of Manjaro running KDE uses about 455MB of memory.

Install a basic KDE Plasma environment

Optional: Install KDE applications

To install a full set of K* applications use kde-applications. This will be ~300 packages(including dependencies)

Alternatively, install a minimal set of KDE applications with kdebase

Optional: Install and use SDDM, the recommended display manager for KDE

SDDM is installed as a dependency of plasma. To enable it

Optional: Install the Manjaro configuration and theming for plasma

Open plasma settings, go to Startup & Shutdown->Login Screen and select 'Breath'

Alternatively, the newer themes may be installed with:

Create a new user for the new desktop environment

Gnome 3

Gnome 3 is an intuitive desktop environment that utilises a tablet or smartphone style interface to access applications. It is not compatible with compiz. Although Gnome is very easy to learn and use, its customisation options are quite limited, and it can be difficult to configure. A 64 bit installation of Manjaro running Gnome uses about 447MB of memory.

Install a basic gnome environment

Optional: To install extra themes, games, and features

Optional: Install and use GDM, the recommended display manager for gnome

GDM is installed as a dependency of gnome, to enable it

Optional: Install the Manjaro configuration and theming for gnome

Create a new user for the new desktop environment

Budgie

The Budgie Desktop is a modern desktop designed to keep out the way of the user. It features heavy integration with the GNOME stack in order for an enhanced experience. A 64 bit installation of Manjaro running budgie uses about 632MB of memory.

Install a basic budgie environment

Optional: Install additional commonly used components

Optional: Install and use LightDM, the recommended display manager for budgie

edit /etc/lightdm/lightdm.conf, under [Seat:*] replace the greeter-session setting with greeter-session=lightdm-slick-greeter

Optional: Install the Manjaro configuration and theming for budgie

To configure LightDM to match the official iso replace the contents of /etc/lightdm/slick-greeter.conf with

Create a new user for the new desktop environment

Cinnamon

Cinnamon is a desktop environment based on Gnome 3 that utilises a large panel-style menu to access applications. It is not compatible with compiz. Despite being based on Gnome, it has more customisation options and is easier to configure. Users of Windows Vista or Windows 7 may find Cinnamon's interface comfortably familiar. A 64 bit installation of Manjaro running Cinnamon uses about 665MB of memory.

Install a basic cinnamon environment

Optional: Install additional commonly used components

Optional: Install and use LightDM, the recommended display manager for cinnamon

Then edit /etc/lightdm/lightdm.conf, under [Seat:*] replace the greeter-session setting with greeter-session=lightdm-slick-greeter

Optional: Install the Manjaro configuration and theming for cinnamon

To configure LightDM to match the community edition replace the contents of /etc/lightdm/slick-greeter.conf with

Set the Manjaro logo on the panel by right-clicking on the menu and clicking configure. Select 'Use a custom icon and label'. Select the Manjaro icon.

Create a new user for the new desktop environment

Deepin

The Deepin Desktop is an elegant, easy to use desktop. It is lightly configurable. A 64 bit installation of Manjaro running deepin uses about 525MB of memory.

Install a basic deepin environment

Optional: Install the deepin applications suite

Optional: Install and use LightDM, the recommended display manager for deepin

Then edit /etc/lightdm/lightdm.conf, under [Seat:*] replace the greeter-session setting with greeter-session=lightdm-deepin-greeter

Optional: Install the Manjaro configuration and theming for deepin

Create a new user for the new desktop environment

Enlightenment

note: There is not currently a Manjaro settings package for Enlightenment

Enlightenment, sometimes known simply as E, is a lightweight desktop environment known for its configurability and tools for creating beautiful user interfaces using its Enlightenment Foundation Libraries (EFL). E started in 1997 as a stacking windows manager, emerging as a desktop environment with development release 0.17. E does not come with a broad array of tools by default, which can be an advantage for experienced users who want to customize their installation, and a disadvantage for users with little or no experience of Linux. E uses a few unique terms, for example referring to panels as “shelves”. A 64-bit installation of E uses about 160M of memory.

Install a basic E environment

Optional: Install and use Entrance, the recommended display manager for E

Entrance is available from the AUR in the package entrance-git. Information on how to install packages from AUR can be found here.

Optional: Install Manjaro themes for E

Create a new user for the new desktop environment

LXDE

note: Installing LXDE will also result in installing Openbox as its default window manager. The LXDM display manager will also be downloaded, although it will be necessary to enable this yourself if you wish to replace your existing display manager.

LXDE is a super-lightweight desktop environment that is very similar to XFCE, with the exception that it is not compatible with Compiz. As with XFCE, LXDE is also a somewhat basic desktop environment, lacking some modern features that would be expected, such as a search-bar to find applications and files. However, it is also an excellent choice for less powerful computers.

Install a basic lxde environment

Optional: Install and use LightDM, the recommended display manager for lxde

Optional: Install the Manjaro configuration and theming for lxde

To configure LightDM to match the community edition replace the contents of /etc/lightdm/lightdm-gtk-greeter.conf with

Create a new user for the new desktop environment

LXQt

The LXQt Desktop Environment LXQt is a lightweight Qt desktop environment. It will not get in your way. It will not hang or slow down your system. It is focused on being a classic desktop with a modern look and feel. A 64 bit installation of Manjaro running lxqt uses about 250MB of memory.

Install a basic LXQt environment

Install and use LightDM, the recommended display manager for LXQt

edit /etc/lightdm/lightdm.conf, under [Seat:*] replace the greeter-session setting with greeter-session=lightdm-slick-greeter

Optional: Install the Manjaro configuration and theming for LXQt

Create a new user for the new desktop environment

MATE

The MATE Desktop Environment is the continuation of GNOME 2. It provides an intuitive and attractive desktop environment using traditional metaphors for Linux and other Unix-like operating systems. MATE is under active development to add support for new technologies while preserving a traditional desktop experience. A 64 bit installation of Manjaro running MATE uses about 378MB of memory.

Install a basic mate environment

Optional: Install mate applications and configuration tools

Optional: Install and use LightDM, the recommended display manager for mate

edit /etc/lightdm/lightdm.conf, under [Seat:*] replace the greeter-session setting with greeter-session=lightdm-slick-greeter

Optional: Install the Manjaro configuration and theming for mate

To configure LightDM to match the community edition replace the contents of /etc/lightdm/slick-greeter.conf with

Create a new user for the new desktop environment

note: By nature, building your own desktop environment from a Window Manager will take substantially more time and effort than simply downloading a pre-defined desktop environment.

Warning: The images provided below are purely for illustrative purposes only. You will have you put in the necessary time and effort to configure them.

Although Desktop Environments commonly provide a good range of customisation options to suit personal taste and preference, they may still be seen as somewhat restrictive or controlled in the sense that they merely allow for the personalisation of their pre-defined components. However, certain Window Managers empower users to take a 'do it yourself' approach in order to create their own desktop environments. In essence, they may be used as a foundation on which to build upon, as literally every component and every aspect of the desktop is under the direct control and choice of the user. An environment may be as elaborate or as minimalistic as desired, and it is even possible to mix and match various components from other desktop environments.

Therefore extremely powerful and versatile, these window managers also carry the additional benefit of being faster and more resource efficient than pre-defined desktop environments. Interestingly, the super-lightweight LXDE environment is itself built on the Openbox window manager. There are two types of Window Manager: Stacking and Tiling. These names denote how application windows will behave on your desktop.

Stacking Window Managers

Stacking window managers are by far the most popular, and essentially allow application windows to be moved freely around the screen, which may overlap - or 'stack' - upon one another, hence the name. All popular desktop environments (e.g. XFCE, KDE, Gnome, etc.) use stacking window Managers.

Openbox

Openbox is by far the most popular Window Manager available. Due to its popularity there is excellent documentation available, as well as a good choice of additional themes that may be downloaded. To install Openbox, enter the command:

To install a logout script, configuration application, menu-editor, and extra themes for Openbox, enter the following command:

Optional: Install the Manjaro configuration, theming, and tools for Openbox

FluxBox

FluxBox is another popular Window Manager. It is particularly notable for providing some features not seen in Openbox, such as tabbing, which allows for windows to be grouped together. To install FluxBox, enter the command:

Optional: Install the newsfetcher and workspace pager for Fluxbox

Optional: Install the Manjaro configuration, theming, and tools for Fluxbox

IceWM

IceWM is a Window Manager notable for perhaps being closer to a full desktop environment than Openbox or FluxBox. This includes providing a panel complete with menu, in addition to a workspace switcher. To install IceWM, enter the command:

To install a suite of tools and themes specifically for IceWM, enter the command:

Tiling Window Managers

Tiling window managers - as the name would suggest - tile application windows; each will have their own place on the screen, just like conventional tiles do not overlap. However, unlike conventional tiling, these window managers are usually very flexible, and allow for a multitude of different tiling patterns to suit personal taste and preference. Where stacking window managers focus on using the mouse for navigation, tiling window managers focus on the utilisation of the keyboard instead. As such, they can be much faster to use.

Awesome

Awesome is a popular tiling Window Manager, notable for using the Lua language for configuration. To install Awesome, enter the command:

To install some extra widgets for Awesome, enter the command:

Alternatively you can install the Awesome Community Edition.

i3

i3 is arguably the most popular tiling window manager available, and notable for using a single, completely self-contained configuration file. To install i3, enter the command:

To install a status bar and screen-locker for i3, enter the command:

PyGnome consists of compiled C++ code (libgnome), compiled Cython code (*.pyx files), and compiled python extensions.It can be installed either from source, in which case you’ll need an appropriate compiler, or from binaries provided by NOAA. However, note that at this time, NOAA is not maintaining current binaries.

Dependencies¶

pyGNOME depends on a number of third party packages – the complete list can be found in the requirements.txt file.

There are many dependencies that can be hard to build, so the easiest way is to use the conda package manager, but you can do it by hand as well – see below.

Building / Installing GNOME with the conda / Anaconda python distribution¶

Anaconda is a Pythondistribution that has most of the difficult-to-build packages thatpy_gnome needs already built in. Thus it’s a nice target for runningGNOME on your own system. “conda” is the packaging manager used to manage the system.

py_gnome CAN be used with any Python distribution, but you will need to find or build a number of packages that are not easy to manage. If you are familiar with complex python packaging, then you can probably make it work. But conda makes it much easier, and that’s what we use ourselves, and support.

Anaconda vs miniconda:¶

Anaconda provides a fairly complete python system for computational programming – it is a large install, but comes with a lot of nice stuff pre-packaged that all works together.

miniconda is a much smaller install – it provides only Python and the conda package mangement system. You can install miniconda, and then install only the packges you need to run py_gnome.

Either will work fine with py_gnome.

NOTES:

Be sure to get the python2 version of Anaconda. py_gnome is currently only python 2 compatible.

Anaconda (and miniconda) can be installed in either single-user or multi-user mode:

We (and Anaconda) recommend single-user mode (Select an install for “Just Me”) – that way, administrator privileges are not required for either initial installation or maintaining the system.

Windows:¶

You want the Windows 64 bit Python 2.7 version. Installing with thedefaults works fine. You probably want to let it set the PATH for you –that’s a pain to do by hand.

OS-X:¶

Anaconda provides a 64 bit version – this should work well withpy_gnome. Either the graphical installer or the command line one isfine – use the graphical one if you are not all that comfortable withthe *nix command line.

Linux:¶

The Linux 64bit-python2.7 is the one to use.

We do not support 32 bit on any platform.

conda¶

conda is the packagemanager that Anaconda is built on. So when working with Anaconda, youuse the conda package manager for installing conda packages. pipcan also be used with conda, but it’s best to use use conda if you can.

As a rule, if you need a new package, you should try to conda install it, and then, if there is not conda package available, you can pip install it.

We have made sure that every package you need is available for conda.

Setting up¶

Install: Anaconda

or alternatively: Miniconda

Once you have either Anaconda or Miniconda installed, the rest of theinstructions should be the same.

Install Ubuntu On Windows Gnome

Update your (new) system¶

Once you have Anaconda or miniconda installed, you should start bygetting everything up to date, as sometimes packages have been updatedsince the installer was built.

First, update the conda package manager itself:

Enter the following on the command-line:

Setting up anaconda.org channels¶

anaconda.org is a web service for hosting conda packages for download. The way this is done is throughanaconda “channels”, which can be thought of simply as places onanaconda.org where collections of packages are bundled together by thepeople hosting them.

Many of the dependencies that py_gnome requires come out of the boxwith Anaconda (or the conda “defaults” channel), but a few don’t.

The “conda-forge” project:

Is a community project to build a wide variety of packages for conda –it supports most of what PyGNOME needs.

However, there a few NOAA-specific packages that are not (yet) on conda-forge,so we have set upour own anaconda channelwhere we put various packages needed for py_gnome.

Adding extra channels to conda:¶

To make it easy for your install to find conda-forge and NOAA pacakges, they shoudl be added to your conda configuration:

First add the NOAA-ORR-ERD channel:

And then add the conda-forge channel:

When you add a channel to conda, it puts it at the top of the list.So now when you install a package, conda will first look in conda-forge,then NOAA-ORR-ERD, and then in the default channel.This order should work well for PyGNOME.Be sure to add the channels in the order we specify.

You can see what channels you have with:

It should return something like this:

In that order – the order is important

conda environments¶

The conda system supports isolated “environments” that can be used tomaintain different versions of various packages. For more informationsee:

NOTE: We highly recommend that you use an environment for GNOME.

If you are only going to use Python / conda for PyGNOME, then you could use the base environment. However, py_gnome needs a number of specific package versions, so it is best to keep it separate from any other work you are doing.

(NOTE: you can do these steps with the Anaconda Navigator GUI if you have that installed)

/toyota-type-regular-download.html. Create an environment for PyGNOME:

This will create an environment called “gnome” with Python2 and the corepieces you need to run conda. To use that environment, you activate itwith:

and when you are done, you can deactivate it with:

After activating the environment, you can proceed with these instructions,and all the packages py_gnome needs will be installed into that environment and kept separate from your main Anaconda install.

You will need to activate the environment any time you want to work withpy_gnome in the future

Download GNOME¶

Once you have conda (or an environment) set up, you can compile and install py_gnome. py_gnome is not currently available as a conda package, as it is under active development, and many users will need access to the source code.

You will need the files from the py_gnome sources. If youhave not downloaded it yet, it is available here:

You can either download a zip file of all the sources and unpack it, oryou can “clone” the git repository. If you clone the repository, you willbe able to update the code with the latest version with a simple command,rather than having to re-download the whole package.

Downloading a single release¶

zip and tar archives of the PyGnome source code can be found here:

This will get you the entire source archive of a given release, which is a fine way to work with PyGnome. However, if you want to be able to quickly include changes as we update the code, you may want to work with a git “clone” of the source code instead.

Cloning the PyGNOME git repository¶

git¶

You will need a git client:

it should be available from your package manager:

git comes with the XCode command line tools:

the “official” git for Windows installer is a good bet:

Once you have the client, it’s as easy as:

This will create a PyGnome directory with all the code in it.

Dependencies¶

The conda packages required by py_gnome are listed in the fileconda_requirements.txt in the top directory of the project.

To install all the packages py_gnome needs:

This should install all the packages required by py_gnome.

(make sure you are in the correct conda environment, and you have theconda-forge and NOAA-ORR-ERD channels enabled.)

If installing conda_requirements.txt fails:¶

If you get an error about a particular package not being able to be installed, then conda will not install ANY of the packages in the file. We try hard to make sure everything is available on one of the channels we recommend. If however, a package of that particular version is missing, you can try:

Edit the conda_requirements.txt file and comment out the offending package by putting a “#” at the start of the line:

That will disable that particular package, and hopefully everything else will install.

You can then try installing the offending package without a version specification:

And it may work for you.

The Oil Library¶

If you want to use py_gnome with “real oil”, rather than inert particles, you will need NOAA’s OilLibrary package:

This is under active development along with py_gnome, so you are best off downloading the sources from gitHub and installing it from source – similar to py_gnome. Though the latest releases of each should be compatible.

cloning the repository

Installing the package:

(you may get a lot of INFO and WARNNG messages as the oil library database is built)

Testing the oil_library install:

(you may need to condainstallpytest to get that command)

you should see something like:

when done.

Compilers¶

To build py_gnome, you will need a C/C++ compiler. The procedure forgetting the compiler tools varies with the platform you are on.

OS-X¶

The system compiler for OS-X is XCode. It can be installed from the AppStore.

Note: it is a HUGE download.

[you may be able to install only the command line tools – Apple keeps changing its mind]

After installing XCode, you still need to install the “Command LineTools”. XCode includes a new “Downloads” preference pane to installoptional components such as command line tools, and previous iOSSimulators.

NOTE: This may be slightly different on different versions of OS-Xand XCode – google is your friend.

To install the XCode command line tools: - Start XCode from thelaunchpad - Click the “XCode” dropdown menu button in the top left ofthe screen near the Apple logo - Click “Preferences”, then click“Downloads”. - Command Line Tools should be one of the downloadableitems, and there should be an install button for that item. Click toinstall.

Once the command line tools are installed, you should be able to buildpy_gnome as described below.

Windows¶

For compiling python extensions on Windows with python2.7 it is best to use the

Microsoft Visual C++ Compiler for Python2.7,

which is freely downloadable.

Linux¶

Linux uses the GNU gcc compiler. If it is not already installed on yoursystem, use your system package manager to get it.

• apt for Ubuntu and Linux Mint

• rpm for Red Hat

• dpkg for Debian

• yum for CentOS

• ??? for other distros

Building py_gnome¶

At this point you should have all the necessary third-partytools in place.

Right now, it is probably best to build py_gnome from source.And it is probably best to build a “develop” target for your py_gnome package if you plan on developing or debugging the py_gnome source code(or updating the source code from gitHub).

Building the “develop” target allows changes in the python codeto be immediately available in your python environment without re-installing.

Of course if you plan on simply using the package, you may certainlybuild with the “install” target. Just keep in mind that any updates tothe project will need to be rebuilt and re-installed in order forchanges to take effect.

OS-X Note:¶

Anaconda does some strange things with system libraries and linking onOS-X, so we have a high level script that will build and re-link thelibs for you.

So to build py_gnome on OS-X:

or:

and to “clean out” the built libraries if the C++ source code changes:

Other platforms¶

The linking issues encountered on OS-X don’t existfor other platforms, so you can build directly the usual way.There are a number of options for building:

> python setup.py develop

builds and installs the gnome module development target.

cleans files generated by the build as well as files auto-generated bycython. It is a good idea to run cleanall after updating from thegitHub repo – particularly if strange errors are occurring.

You will need to re-run develop or install after running cleanall

Install Gnome On Windows Subsystem For Linux

Testing py_gnome¶

We have an extensive set of unit and functional tests to make sure thatpy_gnome is working properly.

To run the tests:

and if those pass, you can run:

which will run some more tests, some of which take a while to run.

Note that the tests will try to auto-download some data files. If youare not on the internet, this will fail. And of course if you have aslow connection, these files could take a while to download. Once thetests are run once, the downloaded files are cached for future testruns.

Running scripts¶

There are some example scripts in the scripts directory. You should be able to run these scripts in the same way as any Python script (with an IDE such as Spyder or PyCharm, or at the command line).

To run a script on the command line:

as an example – there are quite a few.

If you are using a conda environment:

source activate gnome

or on Windows:

Run the script:

Each of the scripts exercises different features of py_gnome – they are hopefully well commented to see how they work.

Installation without conda / Anaconda¶

Since this is development work, it might be good to create and run thisin a virtual environment. Virtualenv and Virtual envwrapper easesmanagement of virtual environments.

A virtualenv is not required to run PyGnome. But you may be workingin an environment (on a corporate network, for example) that restrictsyour access to the system files on your computer. In such a case, youmay require a virtualenv in order to freely install python packages inpython’s site-packages area. (site-packages is the standard place wherepython installers will put packages after building them)

You may also want to consider using conda environments – see above.

There is C++/Cython code that must be built - you will need the correct C compiler and recent setuptools, etc. See “Installing With Anaconda” for more detail.

python.org¶

The following has been tested against Python2.7

Install Windows On Gnome Boxes

Linux (Tested in 64-bit, CentOS)¶

For Linux use appropriate package manager (yum on CentOS, apt-get on Ubuntu) todownload/install binary dependencies.

Binary Dependencies¶

1. setuptools is required.

   >sudoapt-getinstallpython-setuptools` `

2. To compile Python extensions, you need the development libs for Python:

3. netCDF4 python module requires NetCDF libraries:

   libhdf5-serial-dev

   libnetcdf-dev

4. The following python packages, documented in PyGnome’srequirements.txt, may need to be manually installed.

Binaries for

Numpy and

Cythoncan be installed using apt-get.

Current binaries for these are sufficiently new: (Numpy >=1.11.0) and (Cython >= 0.24.1).

If you use virtualenv and apt-get to install these system site packages.Remember to use the --system-site-packages option when creating anew virtualenv so the system packages are available in the virtualenv.

Alternatively, pip install should also work. The following builds thelatest packages in your virtualenv once the above dependencies are met:

Install Gnome On Windows 10 Ubuntu

The remaining dependencies are python packages and can be installed using:

See Build PyGnome section below.

Windows 7 (64-bit, using VS-2008 express edition)¶

For compiling python extensions on Windows, you need the correct version of teh MS compiler: “Visual Studio 2008”. Microsoft has made a versin of this compiler al properly set up for python extensions:

Microsoft Visual C++ Compiler for Python 2.7:

This compiler should work for both 32 bit and 64 bit Windows.

Binary Dependencies¶

Download and install the newest Windows executable distribution ofPython 2.7 (note: we are notquite ready for Python 3.0) Make sure the distribution is namedconsistently with the Python environment you desire. For example,binaries ending in win64-py2.7.exe are for Python 2.7. (64-bit)

A number of the packages that GNOME depends on have very complex andbrittle build processes, and depend on third-party libraries that can bea challenge to build.

Fortunately, Chris Gohlke’swebsite containspre-compiled binary distributions for many of these packages.

(The full list of dependent packages and their minimum versions can befound _in the file GNOME2/py__gnome/requirements.txt)

There are also more binary wheels available every day – it’s worth checking PyPi

Another option is to use a Python scientific distribution, such asAnaconda or EnthoughtCanopy

Here are the binary packages required:

At this point, we should test that pip is installed correctly.On command line invoke the following pip commands.These should show usage information for ‘pip’, and then a list ofinstalled packages:

3. 64-bit 1.0.6 version ofnetCDF4

4. lxml - requiredfor webgnome

5. python-cjson- required for webgnome

The remaining dependencies are python packages and can be installed using the command:

See Build PyGnome section below.

Install Gnome On Windows

Windows 7 (64-bit, using VS-2008 express edition)¶

Building GNOME for 64 bit Windows is similar to the 32 bit Windowsbuild, and has similar binary dependencies. There are however some extrasteps you need to perform in order to build py_gnome.

Install Gnome Ubuntu Windows 10

Build PyGnome¶

1. Clone the PyGnome repository: Fujing web camera driver free download for windows 7.

2. pip install all of GNOME’s python package dependencies:

3. Install the Oil Library package. The OilLibary package is under active development along with py_gnome, so it’s best to install that from source as well:

4. build the py_gnome module in develop mode first as install mode maystill need some testing/work.

   The other option you may need is cleanall, which should clean the development environment – good to do after puling new code from git.

5. If this successfully completes, then run the unit tests:

Once all of the py_gnome unit tests pass, PyGnome is now built andready to be put to use. You can use the gnome module inside yourpython scripts to set up a variety of modeling scenarios.

Install Gnome On Windows 10

There are example full scripts in the py_gnome/scripts directory.