BACKGROUND
high-throughput technologies have boosted biological and medical research and the need for software infrastructures to manage and process the large datasets produced is widely accepted  <cit> .
bioinformaticians are under continuous pressure to both tackle the complexity and diversity of new biological systems and analytical methods and to translate these quickly into flexible informatics infrastructures, while keeping up with the unpredictable evolution of molecular biotechnologies and the increasing scale of experiments.
while standardization of tools and data formats in open source projects like the generic model organism database, gmod  <cit> , and the open bioinformatics foundation, obf  <cit> , have been indispensable in reducing the development efforts needed via reusable and easy to integrate components, new research must also be quickly accommodated, for which efficient software variation mechanisms are needed.
in this paper we present the evolution of molgenis into a generic, model-driven toolkit for the rapid generation of bespoke, data-intensive biosoftware applications  <cit> .
we demonstrate step-by-step how bioinformaticians can use a domain-specific language to efficiently model the biological details of their particular biological system, and use molgenis software generation tools to automatically generate a web application tailored to the experiments of their biologists, building on reusable components.
next, we evaluate the results of these methods in the development of a range of molgenis applications  <cit> , that is, software applications generated using the molgenis toolkit.
we found up to  <dig> times efficiency improvement compared to hand-writing software, while providing a richness of features practically unfeasible to produce by hand but not yet provided by related projects.
we conclude by inviting the bioinformatics community to add more molgenis models, components and generators to quickly generate all the software infrastructures biologists want to have.
methods
the molgenis toolkit is based on the method of model-driven development which emerged in the 1990s from the computer industry.
the key to success is the clear scope of the toolbox  and separating which features should be fixed  and which features should be variable , a process known as domain analysis  <cit> .
below we discuss molgenis’ initial domain analysis, its modeling language, generators and reusable components.
domain analysis
f <dig>  data
f <dig>  control
f <dig>  view
f <dig>  security
f <dig>  extensibility
the second step was to implement the common and variable parts, which we started with a prototype.
here we applied the don’t repeat yourself principle   <cit> : every piece of design knowledge must have a single, unambiguous, authoritative representation.
we therefore searched through the prototype software code.
if we found identical pieces then we put them into the library of reusable components.
if we found very similar pieces of software code, we put the common parts into a generator and the variation points into the modeling language.
in each subsequent step we evolved the molgenis generator, only incorporating new functionality when we repeatedly needed it.
during the next six years of using the molgenis generator we added numerous functions and optimizations, such as filters for the data, viewing data as a ‘matrix’, downloading data as csv files, enabling programming interaction via r and web services, and so on.
the generators ensure that ‘old’ molgenis application variants can benefit from these improvements: when a molgenis instance is re-generated, these improvements are automatically integrated into the new version.
modeling language
one can think of molgenis’ modeling language as a ‘domain-specific language’  that is optimized to efficiently express a particular problem, task or area  <cit> , in this case to compose biosoftware infrastructures.
the level of abstraction is raised, so no lengthy, technical or redundant details on how each feature should be implemented in general programming languages have to be given  <cit> .
examples of other domain-specific languages include r/splus for statistics, matlab for mathematics, sql for databases, html for layouting, and now molgenis’ modeling language for biological software infrastructures.
in most cases, knowledge of the dsl is all that is needed to produce a custom molgenis application variant.
the domain-specific language was implemented using xml so that model files can be edited using off-the-shelf xml editors.
however, you may want to include hand-programmed components into a particular molgenis instance.
for example, for the extensible genotype and phenotype  database application of molgenis  <cit> , we developed a ‘matrixviewer’ that builds on the generated components, which saved us the work of writing the plug-in from scratch.
this requires a model sentence that points to the ‘plug-in’  as well as hand-programming of the plug-in itself.
reusable components
each molgenis application follows the widely accepted three-layered architecture design of web applications.
figure  <dig> summarizes some of molgenis’ reusable components and their variation mechanisms.
molgenis’ reusable components provide building blocks with a modular structure, which allows them to be assembled in diverse combinations, similar to prefabricated houses that are built from modular walls instead of bricks.
some building blocks are semi-finished and need to be ‘completed’ before use .
we based the design of molgenis on industry-proven design patterns from the ‘patterns for enterprise application architecture’ , a catalog of proven solutions for software design problems that we used as a guideline  <cit> .
the logic of the reusable components is implemented using java ; the html layout for the user interface is encoded in freemarker templates ; and the database back-end using mysql, postgresql or hsqldb.
generators
the generators are compact specifications of how each database feature should be implemented.
the molgenis toolkit now has over  <dig> generators, but normal users will never need to take a look inside.
however, for readers wanting to create their own generators, figure  <dig> provides an example of the simple, text-based, generators we use.
each generator consists of two files: a freemarker template that describes the code to be generated  and a java ‘generator’ class that controls the generating process.
a new generator can be developed as follows: first write some examples of the desired programs by hand, where possible using similar patterns  and mark which parts are variable between them.
then copy one of these examples into a generator template  and replace all variable parts with ‘holes’ that are to be filled by the code generator based on parameters from dsl .
at each generation, the template is then automatically copied and the ‘holes’ filled, based on parameters described in the domain-specific language, saving much laborious manual work.
RESULTS
to start generating your own molgenis application, you can download a ready-to-use ‘workspace’ from http://www.molgenis.org, which can be edited using the commonly used eclipse integrated development environment  tool .
extensive manuals are available to help install the java, mysql, tomcat and eclipse software needed and to learn how to walk through the eclipse workspace to edit models and generate and run molgenis instances; most new users can complete this part in about three hours.
below we summarize the output you can expect as well as recent experiences from using this toolbox.
detailed examples on how these features can be used to support actual microarray or genetical genomics experiments can be found in  <cit> .
expected output
after completing a molgenis model and running the generator as described above, you have a ready-to-use software application.
figure  <dig> summarizes the features you get when running the generated result as a web application: a fully functional system where researchers can upload, manage, browse and query their biological data that conform to the model, optionally enhanced with analysis tools to explore and annotate .
an important feature is human readable and printable documentation of your model, including a graphical overview showing relationships in uml❶ which is of great use when still designing and discussing the model in a team.
the next step is typically using the web user interface to populate and test your application with real data❷.
to enable batch loading from a spreadsheet application such as excel, the system comes with a tab-delimited import/export tool tailored for your data which you can use from the user interface as well as via a command-line tool; i.e., the headers of your excel file have to match the fields you have defined in the model, ❸. in our experience, most computational biologists greatly appreciate the use of the r interface to load, analyze and re-store data from within the r statistical environment❹ with web services to connect to workflow tools❺.
finally, advanced programmers may want to customize the layout or integrate their own scripts into the user interface, that is, create plug-ins that are seamlessly integrated with the generated software❻.
typical examples here are the integration of r scripts that produce graphical overviews of the data, enabling them to be run by non-technical research colleagues.
alternatively, you can use soap, rest and rdf interfaces for integration with workflow tools like taverna, or for use with commonly used javascript frameworks like jquery to create ‘web  <dig> ’ interactive websites.
when satisfied with your molgenis system, it can be shared as a simple jar executable using an embedded web server, or as a war file that can be run on public web servers.
applications
since the earliest molgenis application  <cit> , we have successfully evaluated use of the molgenis toolkit to build a wide range of biomedical applications  <cit> , ranging from sequencing to proteomics, including:
• xgap: an extensible genotype and phenotype platform  <cit>  for systems genetics  to store all kinds of *omics data ranging from genotype to transcript and protein data.
xgap comes with plug-ins to view large data matrices and run processing tools on a cluster.
see http://www.xgap.org
• pheno-om: to integrate any phenotype data from locus-specific annotations to rich biobank cohort reports with the help of the ontocat ontology toolkit to create semantic mappings between related data items  <cit> .
see http://www.ebi.ac.uk/microarray-srv/pheno
• findis: a mutation database for monogenic diseases belonging to the finnish disease heritage.
see http://www.findis.org/molgenis_findis/
• hgvbaseg2p: the data management and curation interface complement for hgvbaseg2p, a central database of genotype to phenotype association studies  <cit> .
see http://www.hgvbaseg2p.org
• magetab-om: a microarray experiment data platform based on the mage-tab data format standard to create a local microarray repository that is compatible with the public arrayexpress and geo repositories.
see http://magetab-om.sourceforge.net/
• nordicdb: the database of high-density genome-wide snp information from  <dig>  controls originating from finnish, swedish and danish studies  <cit> .
see http://www.nordicdb.org
• designgg: a web tool to optimally design such genetical genomics experiments  <cit> .
see http://gbic.biol.rug.nl/designgg/
more molgenis applications can be found at http://www.molgenis.org.
each of these molgenis projects reported major benefits from the short cycle from model to running system to enable quick evaluation  and use of the batch loading of data to evaluate how the newly built system works with real data.
more often than not, molgenis helped in finding inconsistencies in existing data that would otherwise have gone unnoticed, leading to experimental errors.
in our experience, a typical molgenis generator run gives you about 90% of the application that is desired ‘for free’, with the remaining 10% typically filled in using plug-ins that are written by hand.
the molgenis toolkit has also been used to extend or replace existing software applications: the extractmodel tool allows you to generate a molgenis application from an existing database, which can then be run side-by-side with code developed previously, providing the best of both generated and hand-written worlds.
richness of features
molgenis provides a richness of features not yet provided by other projects: biomart  <cit>  and intermine  <cit>  generate powerful query interfaces for existing data but are not suited for bespoke data management; omixed  <cit>  generates programmatic interfaces onto databases, including a security layer, but lacks user interfaces; pedro/pierre  <cit>  generates data entry and retrieval user interfaces but lacks programmatic interfaces; and general generators such as andromda  <cit>  and ruby-on-rails  <cit>  require much more programming and configuration efforts compared to tools specific to the biological domain.
turnkey  <cit>  seems to come close to molgenis, having gui and soap interfaces but lacks auto-generation of r interfaces and file exchange format.
CONCLUSIONS
in a recent perspective paper  <cit>  we evaluated the general benefits and pitfalls of model-driven development, such as the ability to develop infrastructure in short cycles to get the application right, ensuring developers and biologists are thinking along the same lines and increasing quality and functionality for all.
we further evaluated applying this method to both microarray and genetical genomics experiments  <cit> ,  <cit> .
here we have presented molgenis in detail and reported the results of using this method against a wider range of applications.
we conclude that using model-driven methods enables bioinformaticians to build biological software infrastructures faster than before, with the additional benefit of much easier sharing of models, data and components.
much less time is spent on customizing and gluing together individual components.
the result is of higher quality because fewer incidental errors creep into the applications as a consequence of the automated procedures; best practices are applied instead of reinvented.
and you do not need heavy-weight technology to implement a model-driven generator: simple text-based templates suffice to create biological software generators.
as a next step we want to expand the molgenis toolkit to also generate data processing tools, including user friendly interaction, building on other ‘model-driven bioinformatics’ projects in this area, such as taverna  <cit>  to model/execute analysis workflows and galaxy  <cit>  to generate user interfaces for processing tools.
we hope that many bioinformaticians will enforce our open source efforts and share their best models, plug-ins and generators at http://www.molgenis.org, so that, in time, every biologist may find a molgenis variant that suits his/her needs.
availability and requirements
project name: molgenis
project homepage: http://www.molgenis.org
operating systems: windows, linux, apple
programming language: java jre  <dig>  or higher
other requirements: mysql or postgresql, tomcat or other j2ee container
license: gnu lesses general public license version  <dig>
any restrictions to use by non-academics: no
abbreviations
api: application programming interface; cpnn: collaborative computing project for nmr; csv: comma separated values; designgg: experimental design of genetical genomics software; dry: principle of don’t repeat yourself; dsl: domain specific language; ebi: european bioinformatics institute; findis: finish disease database; gen2phen: eu project to unify human and model organism genetic variation databases; gmod: generic model organism database project; gui: graphical user interface; gwas: genome wide association study; gwl: genome wide linkage analysis; hgvbaseg2p: human genome variation database of genotype-to-phenotype information; html: hypertext markup language; ide: integrated development environment; jar: java software archive; lgpl: lesser general public license; mage-tab: microarray gene expression tab delimited file format; molgenis: molecular genetics information systems toolkit; nordicdb: nordic control cohort database with harmonized snp information from denmark, estonia, finland and sweden; obf: open bioinformatics foundation; ontocat: ontology common api toolkit; peaa: patterns for enterprise application architecture; qtl: quantitative trait locus; rdf: resource description format; rest: representative state transfer web services; snp: single nucleotide polymorphism; soap: simple object access protocol; sql: structured query language; uml: uniform data modeling language; war: web application archive file; xml: extensible markup language; xgap: extensible genotype and phenotype software platform.
competing interests
the authors declare that they have no competing interests.
authors' contributions
mas and eob conceived the method and designed and implemented the first molgenis generator suite.
mas, md, kjv, ter, ak, jl, da, gb, gat, jm, and ta participated in the development of the molgenis toolkit and/or have been developing applications using molgenis as a platform.
rcj, hp, gat, and ajb have been feeding requirements to steer future development.
mas drafted the manuscript.
all authors read and approved the final manuscript.

 high-throughput technologies have boosted biological and medical research and the need for software infrastructures to manage and process the large datasets produced is widely accepted. bioinformaticians are under continuous pressure to both tackle the complexity and diversity of new biological systems and analytical methods and to translate these quickly into flexible informatics infrastructures, while keeping up with the unpredictable evolution of molecular biotechnologies and the increasing scale of experiments. while standardization of tools and data formats in open source projects like the generic model organism database, gmod, and the open bioinformatics foundation, obf, have been indispensable in reducing the development efforts needed via reusable and easy to integrate components, new research must also be quickly accommodated, for which efficient software variation mechanisms are needed. in this paper we present the evolution of molgenis into a generic, model-driven toolkit for the rapid generation of bespoke, data-intensive biosoftware applications. we demonstrate step-by-step how bioinformaticians can use a domain-specific language to efficiently model the biological details of their particular biological system, and use molgenis software generation tools to automatically generate a web application tailored to the experiments of their biologists, building on reusable components. next, we evaluate the results of these methods in the development of a range of molgenis applications, that is, software applications generated using the molgenis toolkit. we found up to times efficiency improvement compared to hand-writing software, while providing a richness of features practically unfeasible to produce by hand but not yet provided by related projects. we conclude by inviting the bioinformatics community to add more molgenis models, components and generators to quickly generate all the software infrastructures biologists want to have. methods the molgenis toolkit is based on the method of model-driven development which emerged in the 1990s from the computer industry. the key to success is the clear scope of the toolbox and separating which features should be fixed and which features should be variable, a process known as domain analysis. below we discuss molgenis’ initial domain analysis, its modeling language, generators and reusable components. domain analysis f data f control f view f security f extensibility the second step was to implement the common and variable parts, which we started with a prototype. here we applied the don’t repeat yourself principle: every piece of design knowledge must have a single, unambiguous, authoritative representation. we therefore searched through the prototype software code. if we found identical pieces then we put them into the library of reusable components. if we found very similar pieces of software code, we put the common parts into a generator and the variation points into the modeling language. in each subsequent step we evolved the molgenis generator, only incorporating new functionality when we repeatedly needed it. during the next six years of using the molgenis generator we added numerous functions and optimizations, such as filters for the data, viewing data as a ‘matrix’, downloading data as csv files, enabling programming interaction via r and web services, and so on. the generators ensure that ‘old’ molgenis application variants can benefit from these improvements: when a molgenis instance is re-generated, these improvements are automatically integrated into the new version. modeling language one can think of molgenis’ modeling language as a ‘domain-specific language’ that is optimized to efficiently express a particular problem, task or area, in this case to compose biosoftware infrastructures. the level of abstraction is raised, so no lengthy, technical or redundant details on how each feature should be implemented in general programming languages have to be given. examples of other domain-specific languages include r/splus for statistics, matlab for mathematics, sql for databases, html for layouting, and now molgenis’ modeling language for biological software infrastructures. in most cases, knowledge of the dsl is all that is needed to produce a custom molgenis application variant. the domain-specific language was implemented using xml so that model files can be edited using off-the-shelf xml editors. however, you may want to include hand-programmed components into a particular molgenis instance. for example, for the extensible genotype and phenotype database application of molgenis, we developed a ‘matrixviewer’ that builds on the generated components, which saved us the work of writing the plug-in from scratch. this requires a model sentence that points to the ‘plug-in’ as well as hand-programming of the plug-in itself. reusable components each molgenis application follows the widely accepted three-layered architecture design of web applications. figure summarizes some of molgenis’ reusable components and their variation mechanisms. molgenis’ reusable components provide building blocks with a modular structure, which allows them to be assembled in diverse combinations, similar to prefabricated houses that are built from modular walls instead of bricks. some building blocks are semi-finished and need to be ‘completed’ before use. we based the design of molgenis on industry-proven design patterns from the ‘patterns for enterprise application architecture’, a catalog of proven solutions for software design problems that we used as a guideline. the logic of the reusable components is implemented using java; the html layout for the user interface is encoded in freemarker templates; and the database back-end using mysql, postgresql or hsqldb. generators the generators are compact specifications of how each database feature should be implemented. the molgenis toolkit now has over generators, but normal users will never need to take a look inside. however, for readers wanting to create their own generators, figure provides an example of the simple, text-based, generators we use. each generator consists of two files: a freemarker template that describes the code to be generated and a java ‘generator’ class that controls the generating process. a new generator can be developed as follows: first write some examples of the desired programs by hand, where possible using similar patterns and mark which parts are variable between them. then copy one of these examples into a generator template and replace all variable parts with ‘holes’ that are to be filled by the code generator based on parameters from dsl. at each generation, the template is then automatically copied and the ‘holes’ filled, based on parameters described in the domain-specific language, saving much laborious manual work.  to start generating your own molgenis application, you can download a ready-to-use ‘workspace’ from http://www.molgenis.org, which can be edited using the commonly used eclipse integrated development environment tool. extensive manuals are available to help install the java, mysql, tomcat and eclipse software needed and to learn how to walk through the eclipse workspace to edit models and generate and run molgenis instances; most new users can complete this part in about three hours. below we summarize the output you can expect as well as recent experiences from using this toolbox. detailed examples on how these features can be used to support actual microarray or genetical genomics experiments can be found in. expected output after completing a molgenis model and running the generator as described above, you have a ready-to-use software application. figure summarizes the features you get when running the generated result as a web application: a fully functional system where researchers can upload, manage, browse and query their biological data that conform to the model, optionally enhanced with analysis tools to explore and annotate. an important feature is human readable and printable documentation of your model, including a graphical overview showing relationships in uml❶ which is of great use when still designing and discussing the model in a team. the next step is typically using the web user interface to populate and test your application with real data❷. to enable batch loading from a spreadsheet application such as excel, the system comes with a tab-delimited import/export tool tailored for your data which you can use from the user interface as well as via a command-line tool; i.e., the headers of your excel file have to match the fields you have defined in the model, ❸. in our experience, most computational biologists greatly appreciate the use of the r interface to load, analyze and re-store data from within the r statistical environment❹ with web services to connect to workflow tools❺. finally, advanced programmers may want to customize the layout or integrate their own scripts into the user interface, that is, create plug-ins that are seamlessly integrated with the generated software❻. typical examples here are the integration of r scripts that produce graphical overviews of the data, enabling them to be run by non-technical research colleagues. alternatively, you can use soap, rest and rdf interfaces for integration with workflow tools like taverna, or for use with commonly used javascript frameworks like jquery to create ‘web ’ interactive websites. when satisfied with your molgenis system, it can be shared as a simple jar executable using an embedded web server, or as a war file that can be run on public web servers. applications since the earliest molgenis application, we have successfully evaluated use of the molgenis toolkit to build a wide range of biomedical applications, ranging from sequencing to proteomics, including: • xgap: an extensible genotype and phenotype platform for systems genetics to store all kinds of *omics data ranging from genotype to transcript and protein data. xgap comes with plug-ins to view large data matrices and run processing tools on a cluster. see http://www.xgap.org • pheno-om: to integrate any phenotype data from locus-specific annotations to rich biobank cohort reports with the help of the ontocat ontology toolkit to create semantic mappings between related data items. see http://www.ebi.ac.uk/microarray-srv/pheno • findis: a mutation database for monogenic diseases belonging to the finnish disease heritage. see http://www.findis.org/molgenis_findis/ • hgvbaseg2p: the data management and curation interface complement for hgvbaseg2p, a central database of genotype to phenotype association studies. see http://www.hgvbaseg2p.org • magetab-om: a microarray experiment data platform based on the mage-tab data format standard to create a local microarray repository that is compatible with the public arrayexpress and geo repositories. see http://magetab-om.sourceforge.net/ • nordicdb: the database of high-density genome-wide snp information from controls originating from finnish, swedish and danish studies. see http://www.nordicdb.org • designgg: a web tool to optimally design such genetical genomics experiments. see http://gbic.biol.rug.nl/designgg/ more molgenis applications can be found at http://www.molgenis.org. each of these molgenis projects reported major benefits from the short cycle from model to running system to enable quick evaluation and use of the batch loading of data to evaluate how the newly built system works with real data. more often than not, molgenis helped in finding inconsistencies in existing data that would otherwise have gone unnoticed, leading to experimental errors. in our experience, a typical molgenis generator run gives you about 90% of the application that is desired ‘for free’, with the remaining 10% typically filled in using plug-ins that are written by hand. the molgenis toolkit has also been used to extend or replace existing software applications: the extractmodel tool allows you to generate a molgenis application from an existing database, which can then be run side-by-side with code developed previously, providing the best of both generated and hand-written worlds. richness of features molgenis provides a richness of features not yet provided by other projects: biomart and intermine generate powerful query interfaces for existing data but are not suited for bespoke data management; omixed generates programmatic interfaces onto databases, including a security layer, but lacks user interfaces; pedro/pierre generates data entry and retrieval user interfaces but lacks programmatic interfaces; and general generators such as andromda and ruby-on-rails require much more programming and configuration efforts compared to tools specific to the biological domain. turnkey seems to come close to molgenis, having gui and soap interfaces but lacks auto-generation of r interfaces and file exchange format.  in a recent perspective paper we evaluated the general benefits and pitfalls of model-driven development, such as the ability to develop infrastructure in short cycles to get the application right, ensuring developers and biologists are thinking along the same lines and increasing quality and functionality for all. we further evaluated applying this method to both microarray and genetical genomics experiments,. here we have presented molgenis in detail and reported the results of using this method against a wider range of applications. we conclude that using model-driven methods enables bioinformaticians to build biological software infrastructures faster than before, with the additional benefit of much easier sharing of models, data and components. much less time is spent on customizing and gluing together individual components. the result is of higher quality because fewer incidental errors creep into the applications as a consequence of the automated procedures; best practices are applied instead of reinvented. and you do not need heavy-weight technology to implement a model-driven generator: simple text-based templates suffice to create biological software generators. as a next step we want to expand the molgenis toolkit to also generate data processing tools, including user friendly interaction, building on other ‘model-driven bioinformatics’ projects in this area, such as taverna to model/execute analysis workflows and galaxy to generate user interfaces for processing tools. we hope that many bioinformaticians will enforce our open source efforts and share their best models, plug-ins and generators at http://www.molgenis.org, so that, in time, every biologist may find a molgenis variant that suits his/her needs. availability and requirements project name: molgenis project homepage: http://www.molgenis.org operating systems: windows, linux, apple programming language: java jre or higher other requirements: mysql or postgresql, tomcat or other j2ee container license: gnu lesses general public license version any restrictions to use by non-academics: no abbreviations api: application programming interface; cpnn: collaborative computing project for nmr; csv: comma separated values; designgg: experimental design of genetical genomics software; dry: principle of don’t repeat yourself; dsl: domain specific language; ebi: european bioinformatics institute; findis: finish disease database; gen2phen: eu project to unify human and model organism genetic variation databases; gmod: generic model organism database project; gui: graphical user interface; gwas: genome wide association study; gwl: genome wide linkage analysis; hgvbaseg2p: human genome variation database of genotype-to-phenotype information; html: hypertext markup language; ide: integrated development environment; jar: java software archive; lgpl: lesser general public license; mage-tab: microarray gene expression tab delimited file format; molgenis: molecular genetics information systems toolkit; nordicdb: nordic control cohort database with harmonized snp information from denmark, estonia, finland and sweden; obf: open bioinformatics foundation; ontocat: ontology common api toolkit; peaa: patterns for enterprise application architecture; qtl: quantitative trait locus; rdf: resource description format; rest: representative state transfer web services; snp: single nucleotide polymorphism; soap: simple object access protocol; sql: structured query language; uml: uniform data modeling language; war: web application archive file; xml: extensible markup language; xgap: extensible genotype and phenotype software platform. competing interests the authors declare that they have no competing interests. authors' contributions mas and eob conceived the method and designed and implemented the first molgenis generator suite. mas, md, kjv, ter, ak, jl, da, gb, gat, jm, and ta participated in the development of the molgenis toolkit and/or have been developing applications using molgenis as a platform. rcj, hp, gat, and ajb have been feeding requirements to steer future development. mas drafted the manuscript. all authors read and approved the final manuscript. 
each application generated with molgenis comes with an optimized database back-end, user interfaces for biologists to manage and exploit their data, programming interfaces for bioinformaticians to script analysis tools in r, java, soap, rest/json and rdf, a tab-delimited file format to ease upload and exchange of data, and detailed technical documentation. the molgenis toolkit provides bioinformaticians with a simple language to model biological data structures and user interfaces. in recent years we have successfully evaluated the molgenis toolkit for the rapid prototyping of many types of biomedical applications, including next-generation sequencing, gwas, qtl, proteomics and biobanking. the molgenis toolkit provides bioinformaticians with a simple model to quickly generate flexible web platforms for all possible genomic, molecular and phenotypic experiments with a richness of interfaces not provided by other tools. this ‘model-driven’ method ensures reuse of best practices and improves quality because the modeling language and generators are shared between all molgenis applications, so that errors are found quickly and improvements are shared easily by a re-generation.
 there is a huge demand on bioinformaticians to provide their biologists with user friendly and scalable software infrastructures to capture, exchange, and exploit the unprecedented amounts of new *omics data. we here present molgenis, a generic, open source, software toolkit to quickly produce the bespoke molecular genetics information systems needed. methods the molgenis toolkit provides bioinformaticians with a simple language to model biological data structures and user interfaces. at the push of a button, molgenis’ generator suite automatically translates these models into a feature-rich, ready-to-use web application including database, user interfaces, exchange formats, and scriptable interfaces. each generator is a template of sql, java, r, or html code that would require much effort to write by hand. this ‘model-driven’ method ensures reuse of best practices and improves quality because the modeling language and generators are shared between all molgenis applications, so that errors are found quickly and improvements are shared easily by a re-generation. a plug-in mechanism ensures that both the generator suite and generated product can be customized just as much as hand-written software.  in recent years we have successfully evaluated the molgenis toolkit for the rapid prototyping of many types of biomedical applications, including next-generation sequencing, gwas, qtl, proteomics and biobanking. writing lines of model xml typically replaces lines of hand-written programming code, which allows for quick adaptation if the information system is not yet to the biologist’s satisfaction. each application generated with molgenis comes with an optimized database back-end, user interfaces for biologists to manage and exploit their data, programming interfaces for bioinformaticians to script analysis tools in r, java, soap, rest/json and rdf, a tab-delimited file format to ease upload and exchange of data, and detailed technical documentation. existing databases can be quickly enhanced with molgenis generated interfaces using the ‘extractmodel’ procedure.  the molgenis toolkit provides bioinformaticians with a simple model to quickly generate flexible web platforms for all possible genomic, molecular and phenotypic experiments with a richness of interfaces not provided by other tools. all the software and manuals are available free as lgplv open source at http://www.molgenis.org. 9– july the 11th annual bioinformatics open source conference boston, ma, usa 