YousefED
Joined 14 years ago
Joined 14 years ago
- I think administrations in the EU are (slowly but steadily) adopting "Public Money, Public Code" policies and looking more seriously at open source
- Note that policy / strategy on this depends a lot per country / local administration / project etc. I think most governments don't actively develop in house - France is quite the exception in this
- There are a number of conferences that might be relevant (FOSDEM for example just finished)
- We also benefitted from EU grants (e.g.: NLNet) to bootstrap our work and the early research phases
In addition, there are some advanced integrations with other products in La Suite. For example, video calls made in Visio can be automatically AI-transcribed and presented in a Docs document, etc.
I'm fortunate to be collaborating with them as their Docs product is built on top of our open source BlockNote text editor (https://www.blocknotejs.org).
Docs specifically started as an international collaboration with Germany [2] to explore how different EU countries can collaborate in building sovereign workplace solutions (several other countries including NL have shown interest as well).
They're actively supporting us, and related projects like Yjs (https://yjs.dev) by sponsoring feature development.
I'm sure many of the team members will follow along here as well! Happy to answer any questions.
[1] https://news.ycombinator.com/item?id=46873294 [2] https://www.zendis.de/en
We're discussing how to work best with downstream dependencies as well. So far they're actively sponsoring Yjs, but not prosemirror/tt.
fyi, here are some early thoughts by the PM of Docs on how to collaborate between public sector and OSS (companies): https://github.com/virgile-dev/playbook-work-with-oss-librar... (we surely don't check all the boxes yet, but it's good to have the discussion!). Feel free to jump in!
1.5 year ago DINUM (La Suite) and OpenDesk (Germany) reached out and started sponsoring quite a bit of our work which has really helped us accelerate the project
> A killer feature of Observable notebooks for me is that they provide the shortest possible route from having an idea to having a public URL with a tool that I can bookmark and use later
Thanks for sharing simon! I'm working on an Open Source Notion + Observable combination (https://www.typecell.org), where documents seamlessly mix with code, and can mix with an AI layer (e.g.: https://twitter.com/YousefED/status/1710210240929538447)
The code you write is pure Typescript (instead of sth custom like ObservableJS) which opens more paths to interoperability (aside from having a public URL). For example, I'm now working to make the code instantly exportable so you can mix it directly into existing codebases (or deploy on your own hosting / Vercel / whatever you prefer).
Although it's entirely architected on a local-first stack, I indeed haven't shipped the main benefit of this, a locally installable app. There's a WIP PR here that adds PWA support: https://github.com/TypeCellOS/TypeCell/pull/352. I'll highlight this more when this is merged.
Nevertheless, some of the benefits are already noticeable and come "out of the box" with building on a local first architecture, even if not shipping an executable yet: - multiplayer sync - speed: documents are loaded from local storage initially if they have been loaded before, and changes sync in after that
In the future (when there's an installable app), I also want to enable saving / loading from the file system, so that it's completely transparent where your data is.
I'm working on a few projects in this area:
- https://www.typecell.org - Notion meets Notebook-style live programming for TypeScript / React
- https://www.blocknotejs.org - a rich text editor built on TipTap / Prosemirror that supports Yjs for local-first collaboration
- https://syncedstore.org - a wrapper around Yjs for easier development
In my experience so far, some things get more complicated when building a local-first application, and some things get a lot easier. What gets easier is that once you've modeled and implemented the data-layer (which does require you to rethink / unlearn a few principles), you don't need to worry about data-fetching, errors etc. as much as in a regular "API-based" app.
Another interesting video I recommend on this topic is about Linear's "Sync Engine" which employs some of the local-first techniques as well: https://www.youtube.com/watch?v=Wo2m3jaJixU
Excited about Local First software and Future of Programming concepts.
Founder of https://www.blocknotejs.org and https://www.relive.com (outdoor app)