and should it be open source?

I'm taking a break from reporting on the progress of Darklang (it's slow but steady) to write up some thoughts on an interesting question. This weekend on Twitter, Leandro Ostera asked how could it be possible for him to work on  the Caramel programming language full time?

I think about the business models of programming languages quite a bit, and the questions asked in the tweet (and later in the thread) are quite interesting:

• should Caramel be open source?
• would people build their startups on Caramel?
• can Caramel be monetized like Unity or Unreal?
• does Darklang's SaaS approach make sense for Caramel?
• can Leandro charge Caramel's users somehow?

Before we start, what is Caramel? I hadn't really heard of it, so here's a quick intro. Leandro summarized it as "OCaml on BEAM", so it's a functional language like OCaml, but it run on the Erlang BEAM virtual machine. Looking through the docs  it seems it actually uses OCaml's frontend and then compiles it to run on BEAM, where it can interoperate with Erlang.

It's on GitHub, and it seems to be about a year old, with commits almost entirely from Leandro with one other contributor. I'm concluding from this that it's early, with few if any production users yet.

How do we pay for programming languages?

Caramel certainly seems to be a programming language, as opposed to something like Darklang which is a SaaS product that is also a programming language and editor and such.

Programming languages tend to be OSS, so that's a first clue as to what we're looking at here. The reason programming languages tend to be OSS is that like most software projects, the finances tend to follow significant adoption. So the money   for Python development tends to come from companies who have built their stacks in Python paying people to work on Python. This is pretty common with examples such as Ruby, PHP, C++, Scala, Elm, and many many more.

However, that financing is for late stage languages that already  have massive traction. But we're not actually at the success phase in Caramel, instead it's at the phase where the language is still being built.  So how are these languages financed?

Most programming languages are built by large companies (Swift, Objective C, Java, Go, Javascript, Kotlin, Typescript, Rust, C#, F#, Visual Basic), or in academia (Scala, C, C++, Python, Haskell, Lua, OCaml, Elm). Some languages are incubated by their creators financing them themselves with time or existing money, such as D or Clojure.

And finally there are some new languages that are created by venture-backed companies, such as Darklang, Unison, Pulumi, Enso (formerly Luna), Wasp, etc (apologies to all I've forgotten here, send me a note and I'll add you).

Generally, these languages were developed in some way before funding, reaching some interesting usage, capability or other social proof. For example, I raised money for Darklang by pointing to my success at CircleCI. To the best of my knowledge, Enso bootstrapped off service contracts before raising money; Wasp went through YCombinator; Unison was developed for a few years before their seed round, etc.

So let’s go through a few potential funding options for Caramel?

Could Caramel be funded like Unreal or Unity?

Unity and Unreal are games engines that are used by individuals to build games, and also by very very large companies to build games. They monetize by being free for small usage, and then very expensive for large companies or even small companies who start to experience success. They charge with some percentage of revenue, with support contacts, per seat licenses, etc.

So, could Caramel do something like this? My first thought is that the games industry is a sort of a special thing, and different from the world of general-purpose programming languages. The games industry has a lot of money, and there's a long history of companies building products specifically for the games industry. I interned in the games industry back in the PS2 era, and there were tons of companies selling games-industry specific things even back then, like 3D engines, physics engines, networking middleware (I worked here briefly!), etc.

The other thing is that these tools come with a lot of selling, with support contracts, conference visits, etc. If you're selling to the games industry, you probably have a reasonably-sized company supporting it. I also remember a company called Kore trying to sell a version of Lua to the games industry, and it didn't super work out - they pivoted and sold the assets to Havok, which seems to have shelved it.

Even aside from the games industry, Unity and Unreal are products that solve a large problem that few other things solve. Caramel, on the other hand, is not the only functional programming language (which is niche enough anyway), not the only general purpose programming language, not the only way to use BEAM, etc.

Does Darklang's SaaS approach make sense for Caramel?

I firmly believe that how users pay for software should match the design of the system.

Darklang, my company (and the blog you're reading this on), has an interesting approach to monetization. We run Darklang as a SaaS, with the editor in a browser, integrated with the language and infrastructure. Specifically, users don't run darklang on their computers or clouds, which is actually a major part of the design of the Darklang "system"–we believe we can solve a ton of problems in how software is built this way. Given we  don’t want users to run their own version of  it, Darklang is source available, and will one day be monetized by paying for infrastructure, code hosting, etc.

I think Darklang's approach is fairly unique (for better or worse) as it was designed from the start to be financially sustainable by monetizing as SaaS. And the language was designed to have extremely powerful advantages due to being hosted (instant deploys, debugging with production values, automatic upgrades of packages for running software, etc).

DarkLang was also designed to avoid one of the major pitfalls of non-OSS software–its really easy to use, much easier than most OSS since you just open a page in the browser and start coding, which doesn't seem to match Caramel's situation.

Should Caramel be OSS?

I really think the problem Caramel faces right now is adoption. It needs people to use it, to build companies in it, products, build out the ecosystem, etc. So it should remove all possible friction to using it, which for a programming language means it should be OSS. The most frictionless way to install Caramel would be an OSS download via homebrew, Debian, etc.

Users and companies are significantly less likely to use a non-OSS programming language, as if the language developer goes under, they won't have any ability to keep running their programs.

One could argue that users are wrong, since if the people working on a niche language get hit by a bus, its users are fucked anyway, but they could in theory continue to develop it if it’s OSS (similarly, I intend to add a "Darklang goes OSS if Paul gets hit by a bus" provision to the Darklang license for just this reason; hopefully it won't incentivize trying to hit me with a bus though).

What about pseudo-OSS licenses?

Leandro suggested that Caramel would be "open source but licensed". One option here is pseudo-OSS, common in the adjacent space of databases. CockroachDB, Redis, Mongo, etc, have a OSS development model, but a pseudo-OSS license - so does that make sense for Caramel?

The pseudo-OSS licenses used by these companies don't seem to match Caramel all that well. These licenses typically allow users to run instances of the DBs themselves for free, but prohibit predatory cloud providers (cough aws cough) from running them. As a result, they don't monetize directly from it as Leandro is suggesting for Caramel.

Would people build their startups on Caramel?

I'm sure people will someday build startups on Caramel, but it's very unlikely someone would now. Programming languages (and devtools in general) have adoption cycles where individuals get excited and build things on them, discover they love it, and only then do companies get built on them.  The timeframe for this is typically measured in years.

For example, CircleCI was built in Clojure in late 2011. This was one of the first companies built in Clojure, with some others like Factual at the same time. Clojure was publicly released in 2007, and it had been worked on for 2 1/2 years before that, so it was pretty mature. roughly speaking, Clojure in 2011 was about 5 years ahead of where Caramel is now.

Even then, CircleCI wouldn't have had enough money to financially contribute to Clojure until after our Series A in 2014. That said, Clojure is a relatively good model for Caramel because it uses/relies on the JVM in a similar way to Caramel using BEAM.

What about venture backing?

It's not super obvious that venture backing would work here. Most of the venture-backed programming language companies – Darklang, Enso, Wasp or Unison – are  talking about a 10x improvement via some secret sauce.

If Caramel was to go this route, they would likely need to come up with a good monetization strategy. In particular, in the past OSS companies could monetize with service revenues - that's not well regarded in VC these days.

It could potentially monetize with hosting, which that I don't think users are going to want to do. With Cockroach, etc, users would prefer an expert to host their DB, but with the runtime they typically prefer to put it with their existing workloads in Kubernetes, Serverless, etc. Dark gets around this by having a deployless runtime where you don't even think about where the code runs, but something like that doesn't seem to be in the plan for Caramel.

How should Caramel be funded?

It seems that standard programming language financing, such that it exists, matches Caramel that well. Which means that Caramel most resembles the "built as a hobby until it took off" version, like Clojure or Python or Ruby or Elm.

Given its early stage, lack of maturity, and that few companies are likely to build themselves on top of it today, it makes sense to me that adoption should be the main focus of Caramel right now. As such, I would make it OSS and find compatible avenues of funding.

The most likely avenue of funding is crowd-funding. Given that there is quite a lot of excitement around Caramel, I would think that using GitHub sponsors, Patreon, etc is the most likely thing to bring money in. This typically grows over time as there becomes more adoption and awareness, so it's plausible that after a few years it could get to a point of funding one person. I don't know Leandro's personal finances, so this might not be tenable in the short term, of course.

Another approach is to find a corporate sponsor: searching for OCaml companies who want a different backend, or Erlang companies struggling with type safety. I expect Caramel would struggle to get an entire salary out of one company, but it might be less difficult to get a few CTOs who see potential to put $250 a month each into the aforementioned crowd-funding platform.

Read more about Caramel, weigh in  on Twitter, or try out Darklang!