Hi HN! We are Douwe and Jack, founders of
https://neptyne.com. Neptyne is a programmable spreadsheet that runs Python. It’s like Google Sheets, but for software engineers and data scientists. If you have three minutes, go to
https://neptyne.com/neptyne/tutorial and it gives you a taste.
The world runs on spreadsheets, and for good reason: they are a universal data canvas. But building on top of and around the spreadsheet is clumsy: limiting scripting environments, APIs and file formats get in the way of making the spreadsheet a part of a broader application. Excel workbooks become monolithic and unmaintainable. Google Sheets data become static and stale.
Both Excel and Google Sheets offer some level of programmability but we have yet to find any user who liked the experience. It’s harder than it should be, using programming languages that are more limited than you expect. With Excel you've either got VBA or an extension like pyxll to deal with. With Google Sheets, your options are AppsScript or the REST API. These tools are mediocre but the need for programmable spreadsheets is such that people use them anyway.
With Neptyne, the spreadsheet itself runs in the Python runtime, so you can write to it or read from it like an in-memory data structure, because that's exactly what it is.
Neptyne primarily solves problems that exist at the boundaries of what other spreadsheet tools can do. We make Python a first-class citizen of spreadsheet-land, meaning you don't need a clumsy integration or extension to make your code work with spreadsheets. You can use standard off-the-shelf Python libraries to build on top of an Excel-like spreadsheet environment to build collaborative applications. You mix Excel style cell addresses (A1, C3) and ranges (B2:B20) with Python code (e.g. `A1 = "foo" if B2 > 0 else "bar"`, or `for num in B2:B20:`).
Before starting Neptyne we worked at Sidewalk Labs, where we built models in Python that would typically be shared or used via spreadsheets on an interdisciplinary team. The final step of many pipelines was "write a .csv with the results", which was a great way to share data but only in one direction. What we really needed was a way for users to interact with our Python models through a spreadsheet: tune inputs, see results, make quick aggregations. After making some version of this work with the Google Sheets API, we knew this could be better. What we wanted was basically a Jupyter notebook embedded in our spreadsheet, that could give us the full power of Python while keeping the accessibility of a spreadsheet. We built a proof of concept, found some interest in it, and formed Neptyne.
Neptyne differs from lots of modern takes on the spreadsheet tool in that we really wanted to preserve the "data canvas" nature of a true spreadsheet. While there is value in making spreadsheets more like SQL databases with column-based types and formulas, Neptyne gives you the freedom to structure your spreadsheet as you would with Sheets or Excel. Mix and match data types, table dimensions, graphs, charts, and buttons as freely as you might with those tools.
Neptyne behaves exactly like a spreadsheet but is secretly an alternative frontend to a Jupyter Notebook that has an embedded spreadsheet engine. Because it runs a Jupyter kernel, we support anything you can run in a Jupyter notebook, including all the expected visualization packages (matplotlib, plotly, etc.). This is not merely scripting using Python—you can use any (stateful) Python framework to get serious work done.
Things users have built with Neptyne so far include a Twitter bot, a private spaceflight schedule optimizer, and a CRM that pulls from several different data sources.
Neptyne's basic tier is free to use. As we add more capabilities to the product, certain features will be introduced at paid tiers. For individuals building interesting stuff to be shared with the community it will always be free. For teams that need private documents, sharing and custom images, we will charge a team fee.
Here’s a link to some videos: https://www.youtube.com/@neptynehq that show how Neptyne works. If you really want to get a sense of the product, the best way is try out our three minute tutorial: https://neptyne.com/neptyne/tutorial.
We’d love to hear about things you’ve built in spreadsheets and what new things might be possible with a native Python integration! Fire away!
I ran through your demo and I have some feedback:
- Tab completion in the REPL would be great.
- When I change code in the editor, it doesn't update the cell where that code is used until I click on the cell, click away, and click back.
- When I ran the append function, it worked, but if I look at the array in the cell, it's unchanged. If I click on the cell and hit enter, it wipes out the append. I'm honestly not sure what the right behavior here is, I can see use cases on both sides. But initially I did expect the cell with the array to update with the new array.
- When I tried to do autocomplete on the capitals, it failed silently. I assume the API failed to fetch the capitals? It worked on the second try (but took a while).
- When I add a column into the sheet, it breaks all the code that has cell references. I'd expect the code with cell references to get updated unless my references are $F$4 for example, just like in the sheet itself.
Overall though this is a great start!