MonoDevelop 1.0 Released

The MonoDevelop team is proud to announce the release of MonoDevelop 1.0.

MonoDevelop is a GNOME IDE primarily designed for C# and other .NET languages. MonoDevelop enables developers to quickly write desktop and ASP.NET Web applications on Linux and Mac OS X. MonoDevelop makes it easy for developers to port .NET applications created with Visual Studio to Linux and Mac OS X and to maintain a single code base for all three platforms.


The main features of MonoDevelop are:

  • Customizable workbench, including custom key bindings, custom layouts, and external tools.
  • Support for several languages, with C#, VB.NET and C/C++ support included, and Boo and Java (IKVM) support available as separate add-ins.
  • Support for code completion and type information tooltips.
  • Refactoring operations to simplify changes like renaming types and type members, encapsulating fields, overriding methods, or implementing interfaces.
  • Code navigation operations such as jumping to variable definitions and finding derived classes.
  • Easy to use GUI designer for Gtk# applications, also supporting the creation and management of custom Gtk# widget libraries.
  • Integrated source code version control, with support for Subversion.
  • Integrated unit testing based on NUnit.
  • Support for ASP.NET projects, allowing web projects can be built and tested on XSP.
  • Integrated database explorer and editor (beta).
  • Integration with Monodoc, to provide documentation about classes.
  • Support for makefiles, both generation and synchronization.
  • Support for Microsoft Visual Studio project formats.
  • Packaging system that allows generating tarballs, source code and binary packages.
  • Command line tools for building and managing projects.
  • Support for localization projects.
  • Extensible add-in architecture.

The IDE Workbench

MonoDevelop has a highly customizable workbench, based on the traditional user interface model used by most IDEs. The workbench is composed of several pads, which can be moved around by the user and docked in any place. The user can choose which pads to show, and pads can be set to auto-hide mode or floating mode. Other features include:

200px Custom Layouts

MonoDevelop allows saving several layout configurations, so the user can quickly switch to the most convenient layout depending on the task to be done.

200px Configurable key bindings

It is possible to assign a shortcut to any command supported by the IDE. MonoDevelop provides several key binding schemes to ease migration from other environments like Emacs and Visual Studio. It has support for multi-state key bindings (that is, a command can be triggered by a sequence of keystrokes).

200px External tools

The Tools menu can be extended by the user by adding custom commands.

200px Welcome Page

The Welcome Page shows a list of the most recently opened projects, and links to web sites with documentation about Mono.

Projects and Languages

The following table shows the languages supported by MonoDevelop:

Language Compilation Code Completion Class tree Refactory Operations Visual Designer
C# Yes Yes Yes Yes Yes
Visual Basic.NET Yes Yes (no generics) Yes No No
C/C++ Yes Yes (based on ctags) Yes (based on ctags) No No
Boo Yes Yes (no generics) Yes No No
Java (IKVM) Yes No No No No
Other (Generic Project) Yes No No No No

Managed Language Projects

MonoDevelop allows creating different types of managed executables and libraries. Here is a list of the most important features:

  • There are several templates for the different kind of projects: Console project, library, Gtk# application, etc.
  • The build is fully configurable and it is possible to create different build profiles or configurations with specific build options.
  • The Edit References window allows selecting the assemblies that the project requires. The window shows a list of assemblies from all packages installed in the system.
  • Satellite assemblies for localized resources are automatically generated.
  • Support for assembly signing.
  • MonoDevelop allows targeting different runtime versions: 1.1, 2.0 and Moonlight.

C/C++ Projects

The C/C++ project type allows compiling C or C++ code using the GNU gcc or g++ compilers. The compilation and linking is fully configurable, including warning level, optimization level, target type (executable, static or shared library), define symbols, linked libraries, library paths, include paths and arbitrary additional arguments.

Integration with pkg-config enables installed packages such as GTK+ and SDL to be easily added as references. Library projects can also export pkg-config packages for consumption by other projects or for distribution.

The class pad is fully supported (via exuberant ctags), and can be used to browse the defined symbols and jump to their declaration with a simple double-click. This also provides limited code completion in the text editor.

Precompiled headers and dependency tracking are used to speed up the compilation process, and ccache may be used for an additional speed boost.

Generic Projects

Generic Projects (available in the MonoDevelop category of the new project dialog) can be used in a solution to create projects for languages not natively supported by MonoDevelop. For example, it would be possible to create a project which builds a complex C library, or one for handling translation files.

This project type is especially useful in combination with Custom Commands (so you can specify what needs to be done for building/cleaning/executing) and with the Makefile integration (so you can keep the file list in sync with a makefile).

Custom Commands

Users can provide custom commands to be executed before, after or as a replacement of project and solution operations such as build, clean or execute. It is also possible to define new custom operations which will be shown in the project or solution context menu. Commands can be specified per-configuration in the project/solution options dialog.



Source Code Editing and Navigation

MonoDevelop integrates many tools, commands and automations to simplify the editing and browsing of the code. Here is a list of the most important ones:

150px Code completion

Shows a list of types, methods, fields, etc, depending on the editing context. Provides information about method overloads, and shows documentation if available from Monodoc.

150px Parameter information

When typing a method invocation shows the parameters that the method accepts.

150px Type information tooltips

Move the mouse over an identifier, and MonoDevelop will show a tooltip describing what the identifier is, together with full information about its type.

150px On-the-fly error underlining

Syntax errors are highlighted on the fly in the editor, without the need for compilation.

150px Code Navigation

The context menu in the code editor can be used to navigate quickly around a codebase by jumping to the definition, type, or base definition of an identifier. It can also be used to search for references and derived classes.

150px Smart indent

The text editor features a smart indent engine which attempts to keep state as you type and bases indent level on the entire state of the file and not just the indent level of the previous line.

150px Auto-generation of XML comment tags

The editor will enter documentation stubs automatically after typing "/" three times in a comment context. The generated stubs are context-sensitive which will produce the correct default of comments and for existing methods, it will also generate parameter names.

150px Standard Header

The Standard Header manager allows specifying the header to use when creating new files. You can write your own header, or choose one of the default headers provided.

150px Code templates

Simple code templates can be activated by entering the template's keyword, such as 'scwl', and pressing the Tab key. Templates may be added and edited in the Editor Preferences.

150px Class and Member Selectors

The text editor has a class and member selector which allows quick navigation through the contents of the file.

150px Navigation History

The navigation toolbar allows developers to navigate backwards and forwards in their source file position history, either by using the quick Navigate Back/Navigate Forward toolbar buttons or by selecting a particular navigation point via the history dropdown menus in the toolbar.

150px Refactoring operations

The refactoring operations simplify changes like renaming types and type members, encapsulating fields, overriding methods, or implementing interfaces.

Visual Designer for GtkSharp

Easy to use GUI designer for Gtk# applications. Supports the creation and management of custom Gtk# widget libraries.

200px Integrated Visual Designer

The GTK# visual designer is integrated in the IDE workbench. It provides a customizable widget toolbox, a property grid for editing wiget properties, and a widget tree for browsing the structure of a window. The designer generates the required code behind the scenes, using partial classes.

See screencast: Creating a simple user interface with MonoDevelop.

200px Menu and toolbar designer

The menu and toolbar designers are based on the UIManager/Action/ActionGroup model. Building a menu is really easy and 'visual'. You only need to add a menu bar to the window and start writing options. The menu designer looks like a regular menu, but clicking on a menu item makes it selected, so that you can change its properties using the Properties pad. Clicking again on the menu item when it is selected will start the editing mode of the menu item, in which you can change the label or the icon.

When you are creating menu items in this way, the designer creates Actions for each menu item at the same time. Those actions are added to the window's ActionGroup.

200px Stock Icons

MonoDevelop can manage icons to be included in a project. The idea is that you select some images, give them an ID, and MonoDevelop will generate a Gtk.IconFactory for you and will register the icons there. You can then use that ID when creating buttons or anything that requires a stock id.

200px Widget Toolbar

The toolbar located on top of the designer shows some buttons for quickly setting some widget properties. Those buttons change depending on the selected widget.

200px Custom Widgets

MonoDevelop allows creating custom widget libraries. Widgets from widget libraries will be shown in the toolbox, and can be dropped to any window just like the stock widgets. Custom widgets can be created using the visual designer, or by just creating a subclass of a stock GTK# widget (in the latter case, the widget must be explicitly exported in the project options dialog).

See screencast: Creating custom widgets with MonoDevelop.

200px Support for targeting multiple GTK# versions

MonoDevelop supports targeting GTK# versions other than the ones installed in the system. For example, in a system running GTK# 2.10 it is possible to select GTK# 2.4 as target version, and the generated application will be linked against the 2.4 libraries.

Support for those additional GTK# versions must be installed using the add-in manager.


MonoDevelop provides support for creating ASP.NET based web sites. Although there is no visual designer for the web pages, the IDE provides a specific project type which simplifies the development of this kind of web sites.

200px ASP.NET Web Projects

ASP.NET projects can be created, built and tested with xsp. These projects fully support the use of CodeBehind partial classes, auto-generating control references in CodeBehind classes and grouping CodeBehind classes with their parent page. They also feature several templates, support for assembly references in web.config, and type/member compatibility resolution.

200px Deployment of ASP.NET Projects

ASP.NET projects can be deployed to local directories using the Web Deploy command. If the FUSE "sshfs" filesystem is available, it can be used to deploy projects to remote servers.

200px Web References

MonoDevelop provides an "Add Web reference" command, which can be used to create a reference to a web service. This command will generate the proxy classes needed to access the selected web service.

Makefile Support

Working with Makefiles is easy with MonoDevelop:

200px Makefile Generation

MonoDevelop can generate a complete set of makefile scripts for a solution. Two types of makefiles are supported: Autotools based makefiles, and simple makefiles. Simple Makefiles don't depend on Autotools, and are useful for projects which don't need all the features that Autotools provides, but still need to provide the most common targets such as build, install, dist and distcheck.

200px Makefile Integration

MonoDevelop supports integration with Makefiles for projects. This integration covers the following features:

  • Delegating build, clean and/or execute operations to Makefiles
  • Keeping the monodevelop project in sync with the Makefile wrt:
    • List of files (code, resources, deployable files and others).
    • List of references (only for .NET projects). It can correctly handle package references specified in a file.

The add-in allows specifying the regular expressions to be used for parsing compiler errors and warnings. This is especially useful when integrating with makefiles.

Visual Studio Support

MonoDevelop has native support for Visual Studio 2005 solutions/projects. You can directly load VS2005 solutions/projects and work with them. Any changes made are written back to the project files. Currently it supports loading C# (.csproj) and VB.NET (.vbproj) projects.

This support is limited to Files, References, Configurations and Compiler options. No custom msbuild tasks are supported.

This native support is not available for Visual Studio 2003 projects. When opening a VS2003 project, MonoDevelop will offer the possibility of converting it to the native MonoDevelop format or to the VS2005 format.

Version Control

MonoDevelop integrates support for several common version control operations. Right now only Subversion repositories can be used.

See the screencast Using Version Control in MonoDevelop for a live demonstration of the main features, which are:

200px Publish and Checkout

Support for the Publish and Checkout commands, which can be used to import projects into a version control repository, and to get a project from a repository. There is a repository selector which allows registering common repository locations.

Publishing a solution is as easy as selecting the solution, clicking on the Publish command, and selecting the target repository. MonoDevelop will create a new module and will import only the relevant project files.

200px Status View

The status view allows reviewing changes done in files, and allows entering commit comments for each file. Comments are stored on disk, so if you close MonoDevelop and start it again, the status window will show the comments you entered.

200px Solution pad integration

Version control is fully integrated in the solution pad, so operations like renaming, deleting or moving files or folders will be handled by the version control system.

200px ChangeLog generation

The ChangeLog add-in can generate ChangeLog entries for the changes made in the committed files. It supports updating several ChangeLog files in a single commit. Every project can have a ChangeLog location policy (which can be for example: create a single ChangeLog in the root project directory, one in each first-level subdirectory, or one in every subdirectory). When committing a set of changes MonoDevelop will locate and add the comments to the correct ChangeLog for every change (creating a new one if necessary).

Unit Testing

MonoDevelop features integrated unit testing based on NUnit:

200px Tests Tree

The integrated NUnit support can be seen in the Test Tree pad where all the libraries in the solution that contain unit tests, and the text fixture hierarchy for each of them is shown. The tree is automatically updated every time the libraries are built. The test tree makes it easy to run tests by just double-clicking on them, and it shows the result of the the last test run using status icons.

200px NUnit Assembly Group Project

This kind of project is a collection of references to existing NUnit assemblies. This is useful if you have some tests in a dll you want to run, but the dll is generated by some other process outside of MonoDevelop. The tests are shown in the test tree just like any other tests in the solution.

170px History Panel

The NUnit add-in keeps a history of test runs and the results, and you can easily browse them using the results chart and the test details window. The chart shows the progress of successful runs and failures graphically, and it is also used as a date selector. The list below the chart shows a summary of results for the test selected in the tree and at the date selected in the chart.

200px Tests Results Pad

It shows a list of tests executed in a test session. Tests can be filtered by result. In case of failure it will show the failure cause and the stack trace.

Packaging and Deployment

MonoDevelop provides several options for packaging and deploying projects.

200px Create Package Command

The Create Package command allows creating packages for an existing project. It supports three kinds of packages:

  • An archive of sources, which allows choosing the file format (e.g. MonoDevelop or VS2005).
  • An archive of binaries.
  • A tarball.

See screencast: Building packages with MonoDevelop

200px Packaging Projects

A packaging project can be added to a solution and can define several packages to be built for the solution. Each package can be of different kind (archives, tarballs) and can include different project selections.

200px Deployment Model

The packaging system takes advantages of the extensible deployment model implemented in MonoDevelop, which allows specifying the target directory of project files. For example, it is possible to specify that a file needs to be copied to the libs directory, or to the shared directory.

The .desktop file editor Desktop Integration

MonoDevelop includes options to easily integrate applications in the Linux desktop. It can automatically:

  • generate launch scripts
  • create a .desktop file describing the application. Once installed the application will be shown in the desktop application menu.
  • create .pc files for libraries.


The localization add-in simplifies the work of generating and maintaining translations of projects based on gettext.

The add-in provides a new type of project: a Translation Project. It can be added to a solution to provide localization support to all projects in the solution. Adding, compiling and updating the translations is done via the context menu of the translation project in the project browser. When running the Update command, all source files are scanned for translatable strings, and all language files are updated. The add-in also provides a simple .po file editor.


Documentation about class libraries is provided by Monodoc. The F1 help key is context sensitive, and will show the documentation, for the type upon which the text cursor is positioned, in MonoDoc.

Command line tools

Several MonoDevelop features are available as command line tools. All tools can be executed using the command 'mdtool'.

  • mdtool build: Project and solution build tool.
  • mdtool project-export: Project conversion tool.
  • mdtool generate-makefiles: Generates makefiles for a solution.
  • mdtool setup: Add-in setup utility.
  • mdtool gsetup: Graphical add-in setup utility.
A translation project and the .po file editor



MonoDevelop provides an add-in manager that can be used to download and install/uninstall add-ins.

The add-in manager can be started from the MonoDevelop IDE (Tools menu), from the command line (mdtool gsetup), or you can use the command-line version (mdtool setup).

With the add-in manager it is possible to install add-ins from on-line repositories, and keep track of updates. You only need to register the repository url (there is a button in the add-in manager for this), and select the add-ins you want to install. The manager will take care of dependencies between add-ins, or between add-ins and the core assemblies.

MonoDevelop will automatically check for add-in updates once a day (you can change this periodicity in the Add-ins options panel of the preferences dialog).


Getting MonoDevelop

Instructions about how to get MonoDevelop are available in MonoDevelop’s Download page.



Aaron Bockover, Alberto Paro, Alejandro Serrano, Alexandre Gomes, Alex Graveley, Andrés G. Aragoneses, Andre Filipe de Assuncao e Brito, Antonio Ognio, Ankit Jain, Ben Maurer, Ben Motmans, Christian Hergert, Daniel Kornhauser, Daniel Morgan, David Makovský, Eric Butler, Erik Dasque, Franciso Martinez, Geoff Norton, Gustavo Giráldez, Iain McCoy, Inigo Illan, Jacob Ilsø Christensen, James Fitzsimons, Jeff Stedfast, Jérémie Laval, Jeroen Zwartepoorte, John BouAnton, John Luke, Joshua Tauberer, Jonathan Hernández Velasco, Levi Bard, Lluis Sanchez Gual, Marc Christensen, Marcos David Marín Amador, Martin Willemoes Hansen, Marek Sieradzki, Matej Urbas, Maurício de Lemos Rodrigues Collares Neto, Michael Hutchinson, Miguel de Icaza, Mike Krüger, Muthiah Annamalai, Nick Drochak, nricciar, Paco Martínez, Pawel Rozanski, Pedro Abelleira Seco, Peter Johanson, Philip Turnbull, Richard Torkar, Rolf Bjarne Kvinge, Rusty Howell, Scott Ellington, Thomas Wiest, Todd Berman, Vincent Daron, Vinicius Depizzol, Wade Berrier, Yan-ren Tsai and Zach Lute.

This list may not be complete, some contributors who sent patches by email or via our bugzilla may be missing. Your work is still greatly appreciated. If your name was left off the list, it was not intentional, please send an email to the MonoDevelop mailing list and it will be corrected as soon as possible.


Catalan Jonathan Hernández Velasco, Jordi Mas i Hernández
Czech David Makovský
Danish Martin Willemoes Hansen, Jacob Ilsø Christensen
German Gustav Schauwecker, Martin Dederer
Spanish Antonio Ognio, Alejandro Serrano, Andrés G. Aragoneses
French Vincent Daron, Nicolas Favre-Félix
Galician Ignacio Casal Quinteiro
Hungarian Gergely Kiss
Indonesian Fajrin Azis
Italian Alberto Paro, Milo Casagrande
Japanese Atsushi Eno
Dutch André Offringa
Polish Marek Sieradzki
Portuguese Vitor Hugo Barros
Portuguese (Brazil) Mauricio de Lemos Rodrigues Collares Neto, Andre Filipe de Assuncao e Brito, Rafael Teixeira
Russian Maxim Krentovskiy, Semyon Soldatov, Daniel Abramov
Slovenian Matej Urbas
Swedish Daniel Nylander
Turkish Enver Altin
Chinese (China) Yu Lindong, Funda Wang
Chinese (Taiwan) Yan-ren Tsai


To all of our wonderful testers, who had the patience to use unstable versions of MonoDevelop for everyday use, and managed to post nice bug reports.

To Mike Krüger and the rest of the AlphaSierraPapa team for giving us a great codebase to start from, and continuing improvements.

To Pedro Abelleira, Todd Berman, John Luke, and other early contributors who started this adventure 4 years ago, and who believed in the feasibility of the project.

To all of the active and not so active (we miss you!) MonoDevelop developers.