Latest news

November 13-15 2019 the new NEURON core development team met for the first time, hosted by Robert McDougal at the Center for Biomedical Data Science, Yale University in New Haven CT. Besides the project owner and lead developer, Michael Hines, various members from Robert McDougal’s team, the Blue Brain Project’s HPC Team of Felix Schürmann (from EPFL) as well as from SUNY Downstate’s Neurosimulation lab of Bill Lytton attended the meeting. In total, 15 people came together to discuss, learn and code.

The aim of our meeting was explicitly to not only discuss high-level topics and the future roadmap for NEURON, but to also allow the various contributors to meet in person, work on pending issues, and advance code development.

We started off the meeting with discussions of community engagement, and methods to facilitate developer community interactions. One of the outcomes is that we now have an official contributors guide! One major goal of these recent efforts will be to make future contributions into the NEURON code base, as well as tutorials and documentation, more accessible to the community. This will be done by documenting how we develop in this project, by simplifying the development process through better build and testing tools, and by ensuring that the code remains correct as contributions come in through a rigorous continuous integration framework.

In recent months, we began an important effort to introduce a new CMake-based build system that should eventually replace the autotools-based build system, offering more flexibility and simplicity, and rendering NEURON easier to install and maintain. With the introduction of the new build system comes also the integration of components of the NEURON ecosystem, which were previously built separately. InterViews, CoreNEURON and NMODL can now optionally be cloned as submodules into the git repository of NEURON and built as dependencies of NEURON through simple configuration flags. During our codejam sessions we put this new build system to the test, making sure that all participants could build their latest copy of NEURON and further develop it. Specifically we further developed the setuptools-based Python builder in NEURON that will enable us to build pip-installable source and binary distributions, namely sdist and wheels. These pre-built packages will soon be available in the official NEURON pypi repository, allowing NEURON to be installed within seconds on most desktop systems today. Even more exciting is the prospect that these packages will be available within cloud-based Jupyter solutions, making the NEURON environment one click away for the user. To further integrate the ecosystem tools we added support for coreNEURON to NetPyNE and tested several network models. 

Testing is a vital aspect of the software development life cycle, ensuring the correctness and quality of a software project in its current state, and preventing regression as code is added. Thus, we have taken several steps to improve the testing of the NEURON package. First, we setup the catch2 testing framework allowing us to test the lower level C/C++ functions in NEURON, providing the possibility to write both unit and functional tests. Second, we included the pytest framework to test Python functionality of NEURON and RXD, and began integrating the stand-alone RXD tests into pytest. Third, we added a few simple HOC script integration tests (e.g. ringtest) testing NEURON and the HOC interpreter. Finally, to make sure your code changes in NEURON do not introduce regressions, and to help you run newly introduced unit tests for your code, we have included the testing framework into the CMake buildsystem, allowing it to be run with a simple make test.

We want to make the NEURON codebase more accessible to the user, inviting the user community to contribute fixes and improvements. To do this we made a significant effort to improve NEURON’s programmer’s documentation. In addition to the Python and HOC programmer's references and Python tutorials which were added as submodules to the repository, the doxygen documentation framework was added for documenting the C/C++ parts of the code. Furthermore, the doxygen documentation is made automatically available via the travis CI plan in neuronsimulator.github.io/nrn. Of course we will need to now work on adding much more documentation text into the code itself, but we expect that this will be done gradually as we visit the various parts in the code in our future efforts.

After three days of intense coding, testing, building, fixing and discussing, we felt we have not only managed to make a big step forward in NEURON development but also for the NEURON developers themselves through our shared experiences!

We are all looking forward to the next NEURON developers codejam, being planned for April/May 2020.

What: Using NEURON to Model Cells and Networks
When: Friday, Oct. 18 from 9 AM to 5 PM
Where: Downtown Chicago location to be announced

Satellite event to the 2019 Society for Neuroscience Meeting

This course provides a practical introduction to building and using models of neurons and networks with NEURON. Covered topics include basic concepts, workflow for building and using models, speeding up simulations with parallel hardware from multicore personal computers to massively parallel supercomputers, using Python with NEURON, and modeling reaction-diffusion with the RxD class.

The registration deadline for this course is Friday Oct. 4, but you should sign up now because space is limited. See https://neuron.yale.edu/neuron/static/courses/chi2019/chi2019.html for more information and a link to the registration form.

NEURON 7.7.2 is now available for download. It is the recommended version for all new projects.

New features since NEURON 7.6 include:

• Reaction-diffusion enhancements
  • Reimplemented reaction-diffusion simulation support, providing ~10x faster simulations with JIT compiled reactions
  • faster 3D voxelization
  • rxd.Parameters can now be used as fixed concentrations
  • support for specifying electrophysiology models (see, e.g. the Hodgkin-Huxley model implemented using the rxd framework)
  • extracellular simulation support enabled by default
  • SBML export.
  • See the tutorials for examples.
• Python-graphics aware .plot methods for RangeVarPlot and PlotShape.
• Mechanism introspection using new .code() and .file() methods in MechanismType.
• Updated help documentation; all examples should work for both Python 2 and 3.
• Ontology tagging with REPRESENTS keyword for NMODL and represents keyword for rxd.Species.
• Can now initialize MPI with h.nrnmpi_init(); i.e. no need for special flags or mpi4py.
• neuron.units submodule to simplify model specification.
• All platforms can now use nrnivmodl to compile NMODL files; previously Windows could not.
• Python-API enhancements
  • h.SectionList 
    • constructor now accepts a Python iterable of sections
    • methods accept a section argument; no need for sec=
  • Vectors
    • can directly set values; e.g. vec[3] = 42
    • vector.record now returns the vector, allowing one line recording specification; e.g. v = h.Vector().record(soma(0.5)._ref_v)
  • More compact syntax for h.distance and h.RangeVarPlot
  • Simpler NMODL pointer setting; instead of using h.setpointer, can use, e.g. seg._ref_POINTER_suffix = ptr
  • new Section methods: wholetree, subtree that return Python lists of sections
  • new Segment method: volume
  • More meaningful return data types for CVode methods

The 2019 NEURON Summer Course will be held at the University of Minnesota, Minneapolis from Monday, June 10, through Saturday, June 15.

The course will present a thorough introduction to computational modeling of neurons and networks with NEURON, and is suitable for individuals at all levels of expertise. This year continues the 6 day curriculum we introduced in 2017 in order to provide expanded coverage of parallel simulation, and to give participants more time for active learning exercises.

The registration deadline is Friday, May 31, 2019.  No applications will be accepted after that date, and there will be no on-site registration.  Space is limited, and applications will be considered in the order received.

For more information and the on-line registration form, see http://www.neuron.yale.edu/neuron/static/courses/summer2019/summer2019.html

The one-day 2018 NEURON Short Course will be held in San Diego, California on Friday, November 2, 2018.

The course emphasizes practical issues key to productive use of NEURON, including: efficient design and implementation of models and networks, expanding NEURON's repetoire of biophysical mechanisms, and databases for empirically based modeling.

The registration deadline is Friday, October 12, 2018.  No applications will be accepted after that date, and there will be no on-site registration.  Space is limited, and applications will be considered in the order received.

For more information and the on-line registration form, see https://neuron.yale.edu/neuron/static/courses/sd2018/sd2018.html

NEURON 7.6.2 is now available for download.

New features since NEURON 7.5 include:

• Simplified installation
  • Accepting the default install options now allows running from command line and GUI in Mac and Windows.
• Enhanced Jupyter notebook support
  • NEURON error messages now display inside the notebook
  • Experimental notebook ShapePlot available through neuron.gui2
• GUI improvements and bug fixes
  • Sections created in Python are now selectable using the NEURON GUI's "Plot What" functionality
  • MovieRun now works when NEURON is run via Python
  • Per-segment colorization of Shape objects via shape.color(colorindex, seg)
• Extracellular reaction-diffusion support (described in Newton et al., 2018)
  • Available through the neuron.crxd module which also supports intracellular reaction-diffusion with just-in-time compiled reactions
• Miscellaneous enhancements and bug fixes
  • NEURON methods now return appropriate data types (int/bool/float), e.g. pc.nhost() now returns an int
  • Enhanced comparison support for NEURON objects
  • New section methods for morphologies, e.g. sec.pt3dadd()
  • New sec.psection() methods provides a data structure describing that section's properties
  • NetCon.preloc() and NetCon.preseg() now return true NetCon locations
  • Import3D now ignores blank lines in SWC files

The tutorial will present recent advances in methodologies for simulating the electrophysiology of cells and networks in the context of lower and higher scales or organization. At the lower scale, we will describe the simulation of intracellular chemical signals including calcium in subcellular compartments (dendrites and spines), with application to understanding of synaptic plasticity and the response of neuronal dynamics to modulators. At higher scales, we consider the brain as an organ, situating neurons in a complex environment of modulators, ions, and metabolism. The NEURON simulator will be used to illustrate the interactions among these levels, using NEURON's rxd reaction-diffusion module for intracellular and extracellular chemophysiology, and NetPyNE (www.netpyne.org) for managing parameters and for building complex networks of detailed cells as brain structures. We will also introduce new graphical methods (GUIs) for managing these extremely complex simulations. For more information see http://www.cnsorg.org/cns-2018-tutorials#T2.

The 2018 NEURON Summer Course will be held at Emory University in Atlanta, Georgia, from Monday, August 6, through Saturday, August 11.

The course will present a thorough introduction to computational modeling of neurons and networks with NEURON, and is suitable for individuals at all levels of expertise.  This year continues the 6 day curriculum we introduced last year in order to provide expanded coverage of parallel simulation, and to give participants more time for active learning exercises.

The registration deadline is Monday, July 16, 2018.  No applications will be accepted after that date, and there will be no on-site registration.  Space is limited, and applications will be considered in the order received.

For more information and the on-line registration form, see http://www.neuron.yale.edu/neuron/static/courses/summer2018/summer2018.html

Friday, Oct. 27 is the registration deadline for the one day course on NEURON 
http://www.neuron.yale.edu/neuron/static/courses/dc2017/dc2017.html 
and the half day workshop on the Neuroscience Gateway 
http://www.neuron.yale.edu/neuron/static/courses/nsg2017/nsg2017.html.
Space is still available at these events, but if you want to sign up, you'll have to act quickly.

More and more NEURON users are employing Python to build models, so we're making it easier to jump right to NEURON's Python documentation. Click on the "Programmer's Reference" link in the list of resources on the Documentation page, or at the top of any of this site's pages, and you'll see the front page of the Python documentation. If you need the hoc documentation, just click on the "Switch to HOC documentation" link near the top of that page.