Open-source work & personal projects.

Diffuse

I've been working on this personal project on and off since 2012. It started out when some of my favourite music got removed from Spotify. I decided then and there that I'd start buying music and build my own music player. I uploaded my bought music to Amazon S3 and connected it to my Ruby on Rails app. Since then it's evolved into malleable cooperative local-first software (currently in alpha) using custom elements as the foundation.

Everyone has different requirements when it comes to software. Instead of building a monolithic app which has all the possible features and configuration options, we flip this picture upside down and let the user pick the features they want according to their needs. Diffuse also lets you choose the interface. Basically the only things that are mostly consistent are the data structures and web components it's built on. It's also cooperative because you can change the code of any feature or interface in the software itself, and you can share that with other people.

Open Distributed Data

The ODD SDK is a local-first toolkit that helps developers build systems that store data in a secure, reliable, and decentralised way. The focus is on the user, providing them with sufficient authority while still being convenient.

We want our data accessible from anywhere and distributed, meaning it can live partially or fully in multiple places. Ideally, as much of this data as possible lives on user owned devices and communication of this data will be done in a decentralised, peer-to-peer fashion.

This is the main project I worked on during my time at Fission. I still work on projects related to this that use the same protocols WNFS & UCAN. One is a library that wraps the Rust/WASM implementation of WNFS, called Nest, which is something that came out of ODD. Along with these packages.

Shikensu

I was tired of always keeping up with the latest static site generators, so instead I built a library that's one level down of a static-site generator. It's sort of a static-site generator in library format, you write code to generate your website. For example, say you have a folder of markdown articles and you want to generate HTML pages for each of them. You tell Shikensu, through code, to look at your folder that contains the markdown. Then Shikensu scans the entire folder structure and you end up with a data structure that can be manipulated and then optionally written back to disk to, for example, get your HTML pages. You would then instruct Shikensu in code to render markdown, change the extension, wrap the file in a folder, etc.

Through the years I've written various iterations of this, but the basic idea is still the same. The latest iteration is written in Gren (Elm fork/dialect). The one before that was written in Haskell.

main : Shikensu.Program
main =
    -- 🚀
    Shikensu.program sequence CurrentDirectory


sequence : Shikensu.Task -> Shikensu.Task
sequence task =
    task
        |> Task.map (Shikensu.withExtension "md")
        |> Task.andThen Shikensu.read
        |> Task.map
                (\bundle ->
                    bundle
                        |> Shikensu.renameExtension "md" "html"
                        |> Shikensu.permalink "index"
                        |> Shikensu.renderContent renderMarkdown
                )
        |> Task.andThen (Shikensu.write destination)


destination : Shikensu.Focus
destination =
    Relative (Path.directory [ "build" ])

Waves

Electrical-wave analyser.

Circuits

Electrical circuits explained.