HackerReposA FIELD GUIDE TO OPEN SOURCE
ProSponsor the shelf♧ 0
← Back to top all-time
AnswerDotAI
nbdev
Jupyter Notebook2020–2023
AnswerDotAI / nbdev

nbdev

Create delightful software with Jupyter Notebooks

13Distinct people
16Mentions
0Explicit recommenders
5.3KGitHub stars
REPOSITORY AT A GLANCE

What to know before exploring

What it is

Create delightful software with Jupyter Notebooks

GitHub

Where it is used

No documented product use was verified in the last source check.

What people are saying

No recommendation phrase was found in the indexed comments.

No classified warning is attached to this page. Read the discussions before treating silence as approval.

Also in these discussions

Mentioned in the same Hacker News threads. That is not proof they are substitutes.

This week on Hacker News

Nov 7–Nov 14 UTC · Direct repository links and separately labeled related project stories. Indexed through 11/14/2026, 11:56:56 AM UTC.

No direct repository links were found in the indexed HN discussions over the past seven days. Older discussions are available below.

Mentions over time

HN mentions by year16 dated mentions

Observed mentions: 2020-01-25 18:39:17 UTC to 2023-04-13 12:50:03 UTC.

0369122020-01-01 00:00:00 UTC to 2021-01-01 00:00:00 UTC (exclusive): 11 mentions; 1 submissions, 10 comments20202021-01-01 00:00:00 UTC to 2022-01-01 00:00:00 UTC (exclusive): 1 mentions; 0 submissions, 1 comments20212022-01-01 00:00:00 UTC to 2023-01-01 00:00:00 UTC (exclusive): 3 mentions; 0 submissions, 3 comments2023-01-01 00:00:00 UTC to 2024-01-01 00:00:00 UTC (exclusive): 1 mentions; 0 submissions, 1 comments2023

Counts come from the repository’s dated source evidence. Index cutoff: 2026-11-02 08:16:59 UTC.

View mention counts and date ranges
UTC ranges include their start and exclude their end. Select a period to filter the source evidence.
PeriodStart (UTC)End (exclusive, UTC)MentionsSubmissionsComments
20202020-01-01 00:00:00 UTC2021-01-01 00:00:00 UTC11110
20212021-01-01 00:00:00 UTC2022-01-01 00:00:00 UTC101
20222022-01-01 00:00:00 UTC2023-01-01 00:00:00 UTC303
20232023-01-01 00:00:00 UTC2024-01-01 00:00:00 UTC101

What Hacker News says

16 sources
I'm thrilled to see my project (https://mockoon.com) being part of this first cohort! It's a great opportunity but it's also good for open-source projects in general. It can only contribute to make our industry more sustainable. Here is the list of the 20 projects that have been selected: - https://github.com/analogjs/analog: Analog is a fullstack meta-framework to build applications and websites with Angular - https://github.com/Atri-Labs/atrilabs-engine: The Python web framework to build production-grade apps - https://github.com/bigskysoftware/htmx: Makes AJAX, Web Sockets, etc. available directly in HTML - https://github.com/code-hike/codehike: Tools for building all types of code walkthroughs: blogs, docs, slides, tutorials, etc. - https://github.com/DioxusLabs/dioxus: Friendly React-like GUI library for desktop, web, mobile, and mor
Read the rest
e, written in Rust. - https://github.com/EddieHubCommunity/LinkFree: Connecting with your audience with a single link, showcasing your content and projects. - https://github.com/FashionFreedom/Seamly2D: Design CAD to democratize and de-centralize fashion design & production. - https://github.com/fastai/nbdev: Increase developer productivity by 10x with a new exploratory programming workflow. - https://github.com/formbricks/formbricks: Open-source Qualtrics alternative - https://github.com/GyulyVGC/sniffnet: Cross-platform application to comfortably monitor and analyse network traffic - https://github.com/JessicaTegner/pypandoc: Pypandoc provides a thin wrapper for pandoc, a universal document converter. - https://github.com/mockoon/mockoon: Mockoon is the easiest and quickest way to design and run mock REST APIs. - https://github.com/nuxt/nuxt: An intuitive framework for building web applications, built for the edge. - https://github.com/responsively-org/responsively-app: A dev-tool for web developers that aid in faster responsive web page development. - https://github.com/simonw/datasette: An open source multi-tool for exploring and publishing data - https://github.com/spyder-ide/spyder: The scientific Python development environment - https://github.com/strawberry-graphql/strawberry: A GraphQL library for Python that leverages type annotations - https://github.com/termux/termux-app: A terminal emulator for Android that provides 2000+ linux packages to code on phone - https://github.com/TimothyStiles/poly: Poly is a fast, well tested Go package for engineering organisms. - https://github.com/trpc/trpc: End-to-end typesafe APIs made easy. Never write another API contract again. Edit: formatting and updated repo links
In GitHub Accelerator: our first cohort and what’s next
Yes I agree (and share the hope). In fact, earlier today I was thinking about Peter Norvig's "pytudes" (https://github.com/norvig/pytudes) as good examples of literate programming — and they are notebooks. Also, last weekend I picked up some code I had written a few months ago, threw it all away and started writing it in a notebook (Colab) precisely for this "literate programming" reasons. There's also "nbdev" (https://github.com/fastai/nbdev) which seems like it should be the best of both worlds, but I couldn't quite get it to work.
In Literate programming is much more than just commenting code
We're experimenting with `nbdev`[0], especially in our effort to support fast.ai's[1] latest course 'fastbook'[2] on iko.ai[3], to test their notebooks faster. Though scheduling notebooks on our platform is a breeze[4][5] and we could launch the 20 notebooks really fast even manually and check their output while running (some fail that way as they required user interaction for FileUpload or something, and we decided to use fixtures). - [0]: https://github.com/fastai/nbdev - [1]: https://www.fast.ai/ - [2]: https://github.com/fastai/fastbook - [3]: https://iko.ai - [4]: https://iko.ai/docs/notebook/#long-running-notebooks - [5]: https://pbs.twimg.com/tweet_video/Entg8COXcAIDdTI.mp4
In A notebook-free notebook or Jupyter dev env for coders
>is it a new environment, or is it an extended Jupyter Notebook? It looks like Jupyter Notebook to me. Why not Jupyter Lab? Neither? It doesn't change the features of jupyter notebooks, and its not an improved/expanded UI like jupyter lab (you could use nbdev with jupyter lab). Its utilities and automation to make package/library development a better experience if jupyter is where you write your code. From https://github.com/fastai/nbdev: "nbdev is a library that allows you to develop a python library in Jupyter Notebooks, putting all your code, tests and documentation in one place."
In Nbdev: A literate programming environment that democratizes best practices
You can use Markdown with Sphinx in at least three ways: MyST Markdown supports Sphinx and Docutils roles and directives. Jupyter Book builds upon MyST Markdown. With Jupyter Book, you can include Jupyter notebooks (which can include MyST Markdown) in your Sphinx docs. Executable notebooks are a much easier way to include up-to-date code outputs in docs. https://myst-parser.readthedocs.io/en/latest/ Sphinx (& ReadTheDocs) w/ recommonmark: https://docs.readthedocs.io/en/stable/intro/getting-started-... Nbsphinx predates Jupyter Book and doesn't yet support MyST Markdown, but does support Markdown cells in Jupyter notebooks. Nbsphinx includes a parser for including .ipynb Jupyter notebooks in Sphinx docs. nbsphinx supports raw RST (ReST) cells in Jupyter notebooks and has great docs: https://nbsphinx.readthedocs.io/en/latest/ Nbdev is ano
Read the rest
ther approach; though it's not Sphinx: > nbdev is a library that allows you to fully develop a library in Jupyter Notebooks, putting all your code, tests and documentation in one place. > [...] Add %nbdev_export flags to the cells that define the functions you want to include in your python modules https://github.com/fastai/nbdev A few additional sources of docs for Sphinx and ReStructuredText: Read The Docs docs > Getting Started with Sphinx > External Resources https://docs.readthedocs.io/en/stable/intro/getting-started-... CPython Devguide > "Documenting Python" https://devguide.python.org/documenting/ "How to write [Linux] kernel documentation" https://www.kernel.org/doc/html/latest/doc-guide/index.html awesome-sphinxdoc: https://github.com/yoloseem/awesome-sphinxdoc ... "Ask HN: Recommendations for Books on Writing [for engineers]?" https://news.ycombinator.com/item?id=23945580
In Python Documentation Using Sphinx
Late response, but in case you are still looking I don't think I have enough experience just yet to talk about my workflow. For the moment, I'm mostly fine with just running my entire notebook. And yes, my program is "scattered" across cells in a notebook. And that's useful. The blocks are the small units I would want to debug, or to document with markdown above the block. However, you might look to Jeremy Howard of fastai [1] fame for some direction. He apparently built the entire fastai library using notebooks and nbdev [2] which allows you to "add #export flags to the cells that define the functions you want to include in your python modules." I have tried out nbdev in my free time, and it's pretty cool. [1] https://www.fast.ai/ [2] https://github.com/fastai/nbdev
In Ask HN: Which tools have made you a much better programmer?
Jeremy Howard developed the fastai library using Jupyter Notebooks and his nbdev tool[1]. I'm not saying that to disagree with your claim - I don't have enough experience with Jupyter Notebooks yet to have much of a strong opinion on whether or not it discourages modularity. Just that folks who want to have the best of both worlds might be interested in how it can be done. My first thought is that it looks like Donald Knuth's literate programming ideas put to practice, and it has me excited about programming again. [1] https://github.com/fastai/nbdev
In REPL Driven Design
REES is one solution to reproducibility of the computational environment. > BinderHub ( https://mybinder.org/ ) creates docker containers from {git repos, Zenodo, FigShare,} and launches them in free cloud instances also running JupyterLab by building containers with repo2docker (with REES (Reproducible Execution Environment Specification)). This means that all I have to do is add an environment.yml to my git repo in order to get Binder support so that people can just click on the badge in the README to launch JupyterLab with all of the dependencies installed. > REES supports a number of dependency specifications: requirements.txt, Pipfile.lock, environment.yml, aptSources, postBuild. With an environment.yml, I can install the necessary CPython/PyPy version and everything else. REES: https://repo2docker.readthedocs.io/en/latest/specificat
Read the rest
ion.h... REES configuration files: https://repo2docker.readthedocs.io/en/latest/config_files.ht... Storing a container built with repo2docker in a container registry is one way to increase the likelihood that it'll be possible to run the same analysis pipeline with the same data and get the same results years later. ... Pachyderm ( https://pachyderm.io/platform/ ) does Data Versioning, Data Pipelines (with commands that each run in a container), and Data Lineage (~ "data provenance"). What other platforms are there for versioning data and recording data provenance? ... Recording manual procedures is an area where we've somewhat departed from the "write in a lab notebook with a pen" practice. CoCalc records all (collaborative) inputs to the notebook with a timeslider for review. In practice, people use notebooks for displaying generated charts, manual exploratory analyses (which does introduce bias), for demonstrating APIs, and for teaching. Is JupyterLab an ideal IDE? Nope, not by a longshot. nbdev makes it easier to write a function in a notebook, sync it to a module, edit it with a more complete data-science IDE (like RStudio, VSCode, Spyder, etc), and then copy it back into the notebook. https://github.com/fastai/nbdev
In AutoML-Zero: Evolving machine learning algorithms from scratch
My company has a lot of Clojure code but also supports users in R and Python, many of whom code notebook-first. One of the big differences that I have always observed is that Clojure (and other lisps possibly moreso) allow you to use the REPL alongside a living app and codebase. You can interactively develop small chunks of functionality and then integrate them into the whole. Notebooks, however, impose this sort of top-down mental model that in my experience (supporting moving models to production, working with code form academia etc) very rarely leaves you a clear path to a maintainable codebase. Things like nbdev[0] might help a bit with deployment and refactoring, but it still feels like a completely different approach. Fundamentally a lot of people create notebooks as self-contained analysis that runs from top to bottom, first obtain
Read the rest
ing and preparing data, then trying to model the question at hand, and finally presenting results. The model is generally averse to ever scrolling back up. This doesn't feel at all like REPL-based development, where you're experimenting on one small part of a wider web of code, but the REPL history itself is much more transient and throwaway. There certainly can be a core loop in analysis where you're inspecting data, learning the patterns and distributions etc, but that generally yields insights, not code. I assume that this isn't universally true, and many use R/Python REPLs to support more of a code-first approach, but I haven't observed that to be common. 0: https://github.com/fastai/nbdev
In REPL Debugging: No Stacktrace Required (2017)

Showing the 15 most recent of 16 sources. Enable JavaScript to search and browse every indexed mention.

MAKE YOURSELF AT HOME

A few shortcuts

/
Search the collection
?
Open this guide
Esc
Close dialogs and navigation

Your saved repositories and interests stay in this browser.