Sandstorm – An open source operating system for personal and private clouds - <AUTHOR> https://sandstorm.io/ <comment><USER2> For massive take-off, Sandstorm is _almost-there_ with making everyone's online world de-centralized.

It's solved half of the problem beautifully -- it's very easy, once setup, to launch any new app on your server.

The other half of the problem is moving of server/data. Right now, either you use their self hosted instance of sandstorm, or setup your own server. There's the hassle of keeping track of data/server. There's pseudo-centralization happening here, given the difficulty of changing compute or storage by a layperson.

However, if sandstorm had built in federated storage (either based on bittorrent filesystem or any other p2p storage), then I no longer worry about losing my data. I simply move my domain to a new "server-provider" or use the main project's own service, and then at a later date can spin up my own compute, or use another provider, and point them to my data on the p2p/federated storage.

<comment><USER3> FWIW, it's straightforward to see how this could be accomplished with Sandstorm's model, since user data is very clearly divided into grains (app instances / documents) with clear owners, and these grains can easily be transferred between servers. Today, you can click "download backup" to get a zip, then upload it to some other server, and end up with exactly the same grain reproduced there. We plan to streamline this further, to allow mass transfers and synchronizing grains between servers. It's a major goal for us that it should be trivial to move between hosts, so that you're never stuck with a host that you don't like.

<comment><USER2> Good to know. Just to re-iterate one point, the ideal is that the server does not have a hold over the data (by say withholding download of backup data), or that the data is held tied to a certain server.

Server and data (encrypted) should just be commodities, and the domain DNS is what should describe ownership. That's why I would like the focus to be on federation than easy import/export.

<comment><USER3> Realistically, if you want to run code on the server, the server needs some control over the data. There are some distributed systems lately that really only distribute _storage_ while all computation happens client-side. That doesn't work well if you want real-time collaboration (the latency is too high) or multi-user permission constraints. Not to mention, it requires rewriting the world. So, I'm skeptical of those approaches. I'd rather make it easy to get your data out when you need/want to.

But it's certainly an opinion that is open to debate.

<comment><USER2> Copying from a sister comment on this thread:

> To ensure low latency, I'm OK with the protocol allowing a server to cache > and render recent data, while a background service syncs to the de- > centralized store.

This would be a help for the UI from the protocol, but the ideal IMO should be something that normal SaaS companies/products hold you on for -- they have your data hostage.

I understand that for sandstorm above many not be possible as you'd have to re-write a lot, and this feature does not hold sufficient priority for the relevant code re-write to happen.

That's too bad though -- I was expecting this need of mine to be provided by the project. Still I wish you the best of luck as you're head and shoulders the better option above any of the current SaaS apps for a personal clouds.

</comment></comment></comment></comment></comment><comment><USER4> This is an "operating system" only in a marketing hype sense.

In technical reality, it seems to be a Google Apps alternative that you can self-host.

Still very cool (frankly even MORE cool than yet another hobby OS!)... but "platform" would be a less groan-worthy phrase than "operating system".

<comment><USER3> Actually, I agree. We originally used the term "platform". But, we found that people understood more easily when we switched to "operating system" \-- and it's not too far off the mark, honestly. Sandstorm is an OS in the sense that Android is an OS. Both use the Linux kernel, but largely control the userspace. (Sandstorm can run along-side your existing Linux distro without interfering with anything, but it doesn't really use any of your distro's infrastructure so this is somewhat of a technicality.)

The problem with "platform", which surprised me, is that a lot of people now think "platform" is somehow synonymous with "cloud service". For example, if you watch HBO's Silicon Valley, you may remember the whole "platform vs. box" debate from this season. It's a frustrating perversion of the word, but it is what it is.

<comment><USER5> It's actually restricting our thought to an annoying extent that we've overloaded the term "operating system" so much. This isn't Sandstorm's fault -- Windows already has billions of people thinking "operating system" == "desktop environment" so the ship has already sailed.

I would really like a word that describes this set:

      + Unix CLI
      + WIMP desktops
      + Browsers
      + iOS touch interface
      + Android touch interface
      + Emacs (when used for general computing)

Perhaps "user environment" would work?

EDIT: For me at least "platform" doesn't quite fit. I think whatever word is best should imply "single user interface" which platform doesn't necessarily.

<comment><USER6> How about "clam" or "mussel" (as a variant of "shell" that has some meat to it)?

<comment><USER5> Hilarious, but not nearly boring enough to use in actual business writing:)

</comment></comment></comment></comment></comment><comment><USER7> I'm excited. Today was the first time I tried Sandstorm via their demo serivce, and I must say that I am genuinely surprised and impressed with the level of polish. One click gave me a private gitlab, a collaborative document editor, and even a running instance of browserquest!

This level of polish might just be what it takes to get the masses to host their own digital services. I'm strongly considering setting a sandstorm server up for my family.

One question promptly and prominently pops to mind: Given the focus on non- technical users, How does sandstorm mitigate issues that are caused by NAT and NAT traversal?

<comment><USER3> > Given the focus on non-technical users, How does sandstorm mitigate issues > that are caused by NAT and NAT traversal?

At present... not very well, to be honest. If you use sandcats.io (our dynamic DNS), you do have to open port 443, which means you need to understand router config. It would be cool to automate that with UPNP but we haven't gotten there yet. The prevalence of "hairpin routing" bugs in home routers is also a downer. :/

One idea I'd like to pursue someday is the one taken by IndieBox (no longer Googlable -- the one by Johannes Ernst): have a device which sits between your modem and your internal network, so that it can intercept DNS and make the server available at [http://sandstorm](http://sandstorm) or whatever. Then do UPNP to make it externally accessible (if desired).

<comment><USER7> I wasn't aware of Sandcats.io. Thank you for mentioning it.

While it doesn't address all issues, it does go a long way towards mitigating them. I must also take this opportunity to commend you guys on how transport security is handled; the fact that traffic remains secured end-to-end using a host certificate rather than terminating security at the proxy puts sandstorm well ahead of anything else in this space.

Secure, easy, and open source. I'm sold as both a developer and an end-user.

</comment></comment></comment><comment><USER8> I saw this last night and signed up for oasis on my chromebook. I created a Jupyter notebook and entered an expression in it. Nice. Then I closed the lid to my chromebook for the evening.

Next morning I opened up the lid, and it helpfully told me it wasn't connected. I waited a bit longer and updated the expression. The cell text updated but after pressing 'play' the result value did not update, leaving my screen in an inconsistent, incorrect state (wrong value for displayed input to function). There was a little sign telling me I wasn't connected.

I had signed in originally with gmail. People are going to expect a similar interaction model to google docs. There was no obvious way to get back online, short of killing the tab... and getting back how? Remember a link? A bookmark?

This doesn't work yet -- not for most people.

Beautiful, beautiful job. Get the rest of the way there please...

<comment><USER3> Thanks for the feedback.

The connection problem sounds like it may be a bug in Jupyter, or the Sandstorm Jupyter package, rather than Sandstorm itself. It would be great if you could file a bug on the package: [https://github.com/jparyani/ipython/issues](https://github.com/jparyani/ipython/issues)

Usually these kinds of issues are solved by a refresh, though that's obviously not great UX.

> and getting back how? Remember a link? A bookmark?

Go back to: [https://oasis.sandstorm.io](https://oasis.sandstorm.io)

All your stuff is listed when you log in.

<comment><USER8> Almost certainly -- and therein lies a problem for you. There is an ambiguity between who owns the tab -- you or Jupyter app? The user of course will think of you and the app as the same thing. If you let Jupyter throw up a message saying 'you're disconnected' the user will infer that they are disconnected from _you_.

It's not clear the user is wrong btw -- why does a mis-behaving, buggy app, throw me into offline mode? Is it just Jupyter that is offline, or the whole of sandstorm? The message says the tab is. And I can still see components of sandstorm. Of course, I bet if switch to another app it will heal itself -- or will it? Most users won't think of that (or a refresh, or a CTRL+F5, or looking at the debug console for a hint etc.)

So my challenge to you is to explain how the offline/online model works, in a way the user can understand. I suppose big organizations like Google just solve this problem by not hosting buggy apps in the first place. :) :)

It is probably worth your while, from an adoption standpoint, to 'take ownership' of a few key apps and treat their bugs as your bugs -- I would be showing this to coworkers tomorrow if this had worked better, and it probably isn't your fault. They are keen on Jupyter and this is the best delivery platform I've seen for that app. Sharing jupyter notebooks in an enterprise setting could be your killer app -- they contain private data, and a public cloud won't work in many use cases, but most enterprises won't have enough of a constituency of scientists and engineers and statisticians to want to host a notebook server with 'front line' support. We're in the carpet cluster days here...

<comment><USER3> > 'take ownership' of a few key apps and treat their bugs as your bugs

Actually, we plan to do something like that! Though, Jupyter isn't part of the initial set -- our most popular apps are Wekan, Etherpad, Rocket.Chat, and Davros, so we'll be focusing on those.

<comment><USER8> That's good to hear and I see why those would be popular. I'm a bit surprised that a kanban board is so important.

I'll put in my vote for replacing Wekan with Jupyter -- it's more strategic to win mindshare outside the closed circle of developers. The average unsophisticated user who just wants apps, your target market, doesn't want their very own kanban board. A photo album yes. I speculate your early adopters are predominantly developers themsleves and that's why it's popular. It does fit my comment about private data being an important use case for you, of course.

Sharing homework assignments or spreadsheets of data would be more strategic for you, imho. It could help you break into the 'educational shared docs' submarket -- every school I know uses google docs right now for convenience. And don't forget homeschoolers, and teachers setting up courseware sites. I would think the educational market would be _key_ for you to gain mindshare and grow beyond the community of early-adopter developers.

Anyway, best of luck. This is some really good work you are doing.

</comment></comment></comment></comment></comment><comment><USER9> Love seeing this on top of HN, in light of recent discussion about securing your own email. I've tried Sandstorm a couple of times and loved it. They're always improving.

Kenton himself seems ready to respond in depth both whenever Sandstorm is discussed on HN, and at times when I email Sandstorm for support.

I'm sure he's got his limits. He is setting a high bar for customer support within the company. I think that's smart.

Innovation does not happen in a vacuum. Talking to customers with an open mind is a great way to learn what they want and spur some creative process within yourself.

<comment><USER3> :D

We believe in releasing early and often and using feedback to direct development. (Truth be told, this is why the "powerbox" features that we like to talk about a lot aren't totally done yet: user feedback identified many other, more pressing things to improve!)

That said, my dirty secret is that I have a little app that queries HN search every five minutes and gives me a desktop notification whenever Sandstorm is mentioned. :)

<comment><USER9> > my dirty secret is that I have a little app that queries HN search every > five minutes and gives me a desktop notification whenever Sandstorm is > mentioned

I guessed that. You were too good at it. Good job making the name unique haha. Just hope there is no anti-real world sandstorm tech that's developed in the future ;-)

I don't think it's dirty. That's a service itself that other companies would do well to follow by implementing in-house or through investment.

I think many companies do track mentions. Few follow through with real engagement. There is a difference between observing and engaging. In these fast times, I imagine it makes a difference.

Perhaps some users would find this intrusive, and I guess it could be done poorly. I think you set a good example (so far.. ;-) )

<comment><USER10> Google alerts and/or some kind of analytics service can also (to a certain degree) give you an opportunity to answer discussions while they are still active.

</comment></comment></comment></comment><comment><AUTHOR> I just thought this was relevant in light of the recent discussion about how to protect yourself in the event your google account is shut down. Sandstorm has an email client as well - and you can 100% control your data.

<comment><USER11> I've been hoping someone packages nylas for it. I've been meaning to look into how to do this.

<comment><USER3> We have been looking into it too... ;)

</comment></comment></comment><comment><USER12> So I've been thinking a bit more about sandstorm recently as I'm planning to build something and need to work out how I want to host/distribute it.

It'll process data for people and I'd absolutely love to be able to write the app "ignoring" multiple uploads, user management, team-like sharing, etc.

I'd be expecting this to potentially be a paid app though. In app billing is mentioned as a "coming soon", is there a roadmap or expected timescale for this? Is it a "we kinda plan this sometime" or "currently in development, releasing soon" kind of phase?

If not, I don't know how well it'd fit on their shared hosting, as the processing might be fairly intensive. Is it reasonable for me to install sandstorm on a server with my app and let people use that? Sort of like the shared hosting but with only my app available? Does that make sense or am I completely misusing the intended overall structuring of sandstorm?

<comment><USER3> We decide what to do next based on demand, so having someone like you asking us for in-app billing would make it likely to happen sooner. Feel free to email us and tell us about your plans!

With that said, I would expect in-app billing to be at least 3-6 months out, possibly longer if we see more interest for other features first.

However, note that you don't necessarily need in-app billing to sell a Sandstorm app. You could always transact the sale yourself, and then ship an .spk file (Sandstorm package) to the user.

Anyway, please email me (kenton at sandstorm.io) if you'd like to discuss this!

</comment></comment><comment><USER13> Sandstorm is simple an intuitive which is what a lot of our decentralized projects really need a good helping of. I watched the recent Decentralized Web Summit, and there was so much talk about decentralization, yet so little talk about self-hosting, federation or the projects that are out there doing the dirty work today. It made me sad. People are looking for alternatives to silos, not every one of course, but a lot of people just get overwhelmed with the thought of self-hosting. Sandstorm is helping with that it seems. I wrote more about this here[0] if you're curious.

Keep up the good work!

[0] [https://www.alami.io/post/decentralized-web- summit-2016/](https://www.alami.io/post/decentralized-web-summit-2016/)

</comment><comment><USER14> Does this OS provide building blocks for collaborative applications? Or does every app have to reinvent collaborative editing?

Update: Okay, so I created a flowchart in one instance, then shared the link, and opened it in another tab. Edited the flowchart in one tab, but it didn't change in the other tab. This is imho not how a cloud OS should work.

But the container technology seems quite cool.

<comment><USER3> Almost all Sandstorm apps support real-time collaboration. It sounds like you tested draw.io, which unfortunately is one of the few that currently does not.

Sandstorm does not dictate what tech stack you use -- it supports any server stack that runs on Linux. Supporting real-time collaboration is normally the job of your tech stack. If you use Meteor, for example, you'll pretty much have it by default.

Sandstorm does make real-time collaboration easier to operate at scale through fine-grained containerization: each "document" runs in a separate container as a separate instance of the app. Sandstorm ensures that there is never more than one instance running for a particular document, so you don't have to worry about concurrent writes coming from another machine. Scalability is achieved by distributing the documents across machines.

[https://sandstorm.io/how-it-works](https://sandstorm.io/how-it-works)

<comment><USER15> > Scalability is achieved by distributing the documents across machines.

Unless everyone wants to edit the same doc at the same time.

<comment><USER3> Sure, but if you have hundreds of people trying to edit _the same document_ , you are going to have a bad time no matter what architecture you use. This is why Google Docs reverts to read-only mode when too many people show up. We could do something like that too: give the app an API to provide some static content as a fall-back when a grain is overloaded.

</comment></comment></comment></comment><comment><USER16> All the random domain sha1 like domain names are confusing. I also dislike that many of the apps have missing features compared to the actual apps and they get embedded in iframes. I understand all these are done for security.

Related: [https://cloudron.io](https://cloudron.io). Unlike sandstorm, it's docker based and has a very good app store - [https://cloudron.io/appstore.html](https://cloudron.io/appstore.html).

<comment><USER17> Unlike Sandstorm though, Cloudron hosting is limited to managed by them or Amazon's cloud.

Being able to control your self hosted app environment is a big part of why you'd do it.

<comment><USER16> Yeah, I think that is correct. BTW, I just searched and agolia now and found [https://urbit.org/](https://urbit.org/)

<comment><USER18> Urbit is a whole different beast, but shares the same goal:

Decentralization.

</comment></comment></comment></comment><comment><USER19> Still looks a lot like yunohost[1] and cozy cloud[2] which for some reasons I find more attractive than sandstorm. Then we have a rather new contender: ArkOS

[1]: [https://yunohost.org/](https://yunohost.org/) [2]: [https://cozy.io/](https://cozy.io/) [3]: [https://arkos.io/](https://arkos.io/)

<comment><USER20> I'm not entirely clear if you're saying you prefer both yunhost and cozy cloud to sandstorm (or just cozy) - but at least for cozy.io it doesn't really seem like an alternative to sandstorm, as per the faq: "Currently Cozy supports only Node.js applications.", while as can be seen from: [https://docs.sandstorm.io/en/latest/vagrant-spk/packaging- tu...](https://docs.sandstorm.io/en/latest/vagrant-spk/packaging-tutorial/)

"The tutorial uses a PHP app as an example. Sandstorm supports any programming language that runs on Linux, not just PHP, such as Meteor, Python, Rails, Node, PHP, C++, Go, Rust, and more. Read about vagrant-spk's platform stacks to see how to optimize your package for your app's programming language."

As for yunohost it looks like it is more comparable - but essentially is a "cpanel on steroids" \- a nice way to automate managing classic server applications:

[https://yunohost.org/#/whatsyunohost](https://yunohost.org/#/whatsyunohost)

Thank you for mentioning these, I wasn't aware of either -- but I don't think they really are an alternative to most of the use-cases sandstorm excel at.

Arkos seems similar to yunohost, although rather than an easy way to manage Debian, it's an easy way to manage Arch on arm (a curios limitation IMHO):

[https://arkos.io/what-is-arkos/](https://arkos.io/what-is-arkos/)

<comment><USER19> Let's put it this way, both are part of a larger effort to put the web back in tracks by having more people self-host their data and web services. Then sandstorm uses a third party google service to track visitors while cozy and yunohost use a self-hosted instance of piwik. One of those is not putting his money where his mouth is...

Sandstorm is made from an ex-google employee while cozy has the founder of the european branch of mozilla in its ranks.

Then there is the AMD64 limitation of sandstorm, while the other offer support for ARM, the de facto architecture for a low consumption personal server.

I think the sandstorm.io website is dense and hard to comprehend, it's not to the point and from the get go I can tell it's pretending to be something it is not (an OS).

Also the sandstorm demo feels clunky to me and I experience random crashes and error messages while trying apps in sandstorm.

In the end my preference goes to yunohost because it's not from a funded startup with a full team which may explain why it stayed simple and within reach.

IMHO ArkOS is closer to freedombox than yunohost, also supporting ARM is _the_ feature not a limitation as it seems obvious that the personal self-hosted server is running on cheap, low consumption embedded ARM. To me a curious limitation is not supporting ARM.

<comment><USER20> I think I disagree with almost all your points here (or that they are a reasonable criticism/list of things that should be changed with sandstorm) -- but I appreciate you taking the time to respond in such detail. (Modded your comment up FWIW).

Didn't realize that Sandstorm (currently) targets only AMD64 - for others interested, the rationale is here:

[https://github.com/sandstorm- io/sandstorm/issues/94](https://github.com/sandstorm-io/sandstorm/issues/94)

I don't really see this as much of a problem - at a later point, if Sandstorm is packaged for something like Debian, it's likely people will work on porting it to Arm. As most of the software is already ported, this shouldn't be insurmountable.

</comment></comment></comment></comment><comment><USER21> OK so this _looks_ awesome and I had half a dozen ideas for things I'd like to do with it in about 30 seconds. Is anyone using it? Would love to hear from some experienced commentors.

<comment><USER22> I've been using Sandstorm as my primary document writing and storage location for a while. I've mostly been using the Oasis hosted service (and their alpha server prior), but I've also installed Sandstorm on a couple of VMs for dev and testing purposes. I'm pretty happy with it, and happy with the apps available for it.

There's still some things I'm waiting for, such is the life of using a platform that's still in development by a small team. Some way to organize my grains is the big one left right now. But especially recently a lot of the stuff "down the roadmap" is starting to feel finished. The Powerbox features are getting there. Active Directory integration exists now.

Since somewhere in 2014 when I started playing with it, it's always felt like it was moving forward.

<comment><USER23> Agree, I miss some way to organize, group or tag the grains/docs.

If a folder structure will be implemented, sharing options should also be available for folders, I think.

<comment><USER3> That's coming, probably in the next week! :D

</comment></comment></comment></comment><comment><USER24> I am using Sandstorm and I love it. Nothing beats the power of hosting your own private cloud. However, I really wish there was a way around the wildcard certificate requirement. One of these days I am going to shell out $100 for a wildcard cert or I can just hope Let's Encrypt will support it!

<comment><USER3> Thanks!

You probably know this already, but for others: Sandstorm offers free wildcard certs if you'll settle for a subdomain of sandcats.io.

And because I'm sure other people will ask, here's the FAQ on why we need the wildcard certs: [https://docs.sandstorm.io/en/latest/administering/wildcard/#...](https://docs.sandstorm.io/en/latest/administering/wildcard/#why- sandstorm-needs-wildcard-dns)

</comment></comment><comment><USER25> Speaking of which, what is the status of Cap'n Proto? I was looking at using it for a side project recently, but it doesn't look great on the surface: there haven't been any updates on the site since March of last year, and that post was to address a security vulnerability.

<comment><USER3> Cap'n Proto is essentially a sub-project of Sandstorm. Lately, there hasn't been a whole lot of churn in Cap'n Proto land as it is doing what we need it to do. That said, there are a few features I'm becoming increasingly eager to implement, probably later this year. The biggest one is three-party handoff: when Alice holds a capability pointing towards Carol and sends that capability to Bob, then Bob should form a direct connection to Carol rather than proxy requests through Alice. This will be important for improving scalability of the cluster version of Sandstorm, although at the moment it's getting along fine without it.

But yeah, Sandstorm uses Cap'n Proto extensively, so if there's no updates to Cap'n Proto, it's because its biggest user hasn't seen a need to make many changes. :)

</comment></comment><comment><USER26> Can you explain the "Fine-grained Object Containers" concept a little more?

For example, how is this enforced: "JavaScript running in the user's browser can talk only to the document container for which it was loaded, no others."

Do apps need to be SandStorm aware? Thanks!

<comment><USER3> Hi! There's an extensive explanation here: [https://sandstorm.io/how-it- works](https://sandstorm.io/how-it-works)

To answer your questions:

> For example, how is this enforced: "JavaScript running in the user's browser > can talk only to the document container for which it was loaded, no others."

Each grain (or actually, each session on each grain) is assigned a randomly- generated subdomain. These domain names are unguessable, so there's no way for one grain to know another's domain, and anyway same-origin policy generally prevents Javascript from interfering with other domains. (In the future, we plan to further lock down the client side using Content-Security-Policy, although we haven't done this yet.)

> Do apps need to be SandStorm aware?

Yes, apps need to be packaged for Sandstorm, and that usually involves some modifications to the app. However, the modifications are usually mostly deleting code: you delete your user management and rely on Sandstorm, and you delete your multi-document management and instead let the user create multiple grains at the Sandstorm level. Typically, this work takes a few hours, though it varies depending on the app.

(It's also worth noting that apps which target exclusively Sandstorm from the start are much easier to write than normal web apps: User management, document management, security, access control, etc. are handled for you.)

<comment><USER26> Thanks. I'd poked through the howitworks. What threw me off was the reference to Etherpad, which made me think apps could somehow run on SandStorm unmodified. Makes sense now!

</comment></comment></comment><comment><USER27> Is there a way to run e.g. an email server on Sandstorm?

Last time I looked it seemed like that would never be supported because it would violate the sandstorm business model, which, as I understand it, appears to be selling very cheap hosting of grains, made possible because only disk resources are used when an grain is not currently in use.

This would seem preclude the hosting of services that need to be running all the time in the background.

<comment><USER3> Sandstorm's business model is selling enterprise-oriented add-ons and support (e.g. ability to integrate with LDAP/SAML/Active Directory, or (eventually) providing HIPAA compliance, etc.). The hosting service actually exists more so that developers know that their apps are usable by everyone, not just people who run their own server.

There's actually no need for a mail server to be always-on. It could start up whenever a message arrives. Sandstorm is good at this kind of on-demand starting.

We very much intend to support using Sandstorm as your email server. It turns out, though, that e-mail is a complicated subject which operates on a different set of protocols from the rest of the web (SMTP vs. HTTP) and has a whole lot of hairy stuff you need to do to make it actually work (SPF, DKIM, ...). Since there are quite a few options out there already for handling email, we've chosen to focus elsewhere in the short term, but I hope to loop back to email in the coming months.

</comment></comment><comment><USER28> All the examples I see on your demo are web apps (and the documentation seems to be focused on web apps as well).

How well are applications without a web-interface supported?

For example, could I easilly package and launch something like a teamspeak server on sandstorm, or would I need to add some mock web server that kept the real server online?

<comment><USER3> You would need to add a web UI for configuring the server, as the user won't be able to SSH in and edit config files. (This is by design: forcing users to use shells and text editors is terrible UX.)

Currently, you would also need to request a raw IP networking capability from the user. Only admins of the Sandstorm server are able to grant this capability, for security reasons. So if you are self-hosting Sandstorm, you're good, but you wouldn't be able to run the app on Oasis currently. We are working on better solutions here.

Jason (a Sandstorm employee) has been playing around with packaging a Mumble server, proving that this sort of thing is possible: [https://groups.google.com/d/msg/sandstorm-dev/kfd- zcSJqb4/2f...](https://groups.google.com/d/msg/sandstorm-dev/kfd- zcSJqb4/2fnAvEPxBAAJ)

</comment></comment><comment><USER29> I realise I'm coming late to this thread, but just a quick question. But before that, a big hats off to everyone involved with Sandstorm! Making a complex platform point & click is a huge achievement.

Coming to my question, does Sandstorm have a HTTP server in its app platform? While I'm excited about other apps like file sharing/storage, what I badly want to do right now is to be able to host my site on my own machine using dynamic DNS. Of course I can manually do it by installing Apache, configuring it, updating a dyn DNS provider and so on. But if Sandstorm offers a point & click way to do that, then I'm hooked right now. :-)

<comment><USER3> If it's a static site, there are several apps on Sandstorm you can use: Wordpress, Ghost, Hacker CMS (which is basically Jekyll + a text editor), or Davros (to which you just upload files, and then publish). Any of these will allow you to connect an arbitrary domain to the page so that visitors see your content only, not Sandstorm.

If you want to publish a dynamic site with server-side logic, that's currently not supported, unless you are OK with it being a Sandstorm app, which means everyone who accesses it will see the Sandstorm UI around it.

<comment><USER29> Thanks for replying! A static site over SSL on a custom domain will do well right now. Presently I'm using the motley combination of uploading HTML to Github Pages and placing Cloudflare in front (for SSL on a custom domain), but Sandstorm sounds like a more painless alternative that would also mean I retain my data on my own machine. Will get started!

</comment></comment></comment><comment><USER30> How do app updates work with Sandstorm ? For example, if I host an instance of the Ghost blog. Now, say it updates from version 1.2 to version 2.0 (which means probably a breaking database schema change or something). How would Sandstorm go about updating it ?

<comment><USER31> A grain's filesystem consists of read-only app data mounted at / and writable grain storage mounted at /var/. From Sandstorm's perspective, upgrading a grain to a new app version just means launching the grain with the new app version's read-only data, leaving the writable /var/ data untouched. The app is then responsible for detecting if any migrations are required and for performing them if so.

Some apps, such as WordPress, already have logic for automatically updating the database when the code changes. Other apps need to add some simple version-detection logic in their startup scripts.

<comment><USER30> Thanks for the explanation !

</comment></comment></comment><comment><USER32> Very cool! Last time I checked Sandstorm, the powerbox system was still in development. Now it seems finished, according to the docs. Is there are more in-deptg doxumentation about the UI flows and APIs?

<comment><USER3> It's not totally finished yet, but parts of it are finished and will start being used by real apps in the next week or two.

The reason it has taken a while is not because it was hard, but rather because we've been repeatedly pulled away by other, more-pressing concerns, e.g. basic usability issues or features like the activity/notifications API (which turns out very important for people trying to do real work on Sandstorm).

The most in-depth documentation is the .capnp files in the source tree. We will be writing better documentation as the features stabilize (soon).

</comment></comment><comment><USER33> OS seems a little presumptuous. As does the majority of the "how it works" page. Making wildly ridiculous claims that amount to "microservice are silly" (my paraphrase) when really they've only managed to successfully sandbox applications. Much like Android with its "a user for every app by default."

> Sandstorm takes a wildly different approach [than containerized services]: > It containerizes objects, where an object is primarily defined by data

Or... You've containerized the data access service and enforced a per- application sandbox. Plenty of precedent there.

> Microservices are seemingly designed to match the developer's mental model > of their system. Often, services are literally divided by the team who > maintains them.

Good Lord, I sure hope that's not true. Maybe if the non-technical manager designed the system.

> In the Sandstorm model, all of the components (from web server to database) > needed to handle a particular grain run on the same machine.

So your container scheduler can optimize for I/O. Again not that far from existing cloud schedulers.

I'm not saying this isn't a powerful model or platform. I am saying that I'm very disinclined to want to work on such a platform, purely because I'm worried its developers buy into the "everybody else is way off base" attitude, when really they're only doing what many many successful architectures have done before them.

<comment><USER3> Hi! I'm the founder / tech lead of Sandstorm. I wrote that "How it Works" page ([https://sandstorm.io/how-it-works](https://sandstorm.io/how-it-works)) and designed the architecture it is describing. Before Sandstorm, I worked at Google on infrastructure for eight years. As you may know, Google has been doing containers and microservices for over a decade. What I describe on the page is largely based on that experience.

> Plenty of precedent there.

I've personally never observed a production (non-research) server architecture which containerizes and sandboxes application servers on a _per-document_ level. That is, say, with Etherpad on Sandstorm, every document you create is in a separate container isolated from the others.

I would love it if you could name some specific examples that work this way, as I'd very might like to see what others have done.

<comment><USER34> I get the grain-per-document thing. Sounds interesting for at least a subset of applications, and disagree with the grandparent that it's common practice.

First question that comes to mind is how the data source is sharded like that. You say in another post that you don't mandate a tech stack. So let's say I want to store my data in MySQL. Are you saying each document literally has its own private database instance?

I have many more questions, but they will depend on your answer to that question. :)

<comment><USER3> > Are you saying each document literally has its own private database > instance?

Yes. Each "grain" (our catch-all term; could mean "an Etherpad document" or "a Gitlab repo" or "a Wekan board", etc.) gets a slice of filesystem to do whatever it wants with.

Of course, MySQL is totally overkill for this task. We generally encourage people to use sqlite instead. But there are a couple apps that do actually run MySQL in the container, mostly because switching to sqlite would have been too much work. There are also several apps that use Mongo, but it turns out Mongo 3's WiredTiger engine is reasonably efficient for small data sets, so it works out.

The model definitely is friendlier to some kinds of apps than others. Productivity apps with clear data boundaries -- Etherpad (document editor), Wekan (Trello clone), Rocket.Chat (Slack clone), Gitlab, etc. -- work very well, and are our main focus. "Big data processing" apps are not well-suited to this model. We're happy to cede those, as there are tons of people doing great work in that domain.

<comment><USER35> In the case of Rocket.Chat, is each channel a grain or is the entire chat a grain? It appears to me it should be a grain but I am not sure.

<comment><USER3> Currently, the whole Rocket.Chat instance is a grain.

However, it would be "more Sandstorm-y" if each channel were a separate grain. For that to work well, though, we need some UI features to emulate what Rocket.Chat already does internally:

* The ability for grains to highlight themselves in the sidebar when there is activity or when you've been mentioned, so that you know to check them. This API actually just launched last week! So now the apps are being updated to use it.

* Some way to create "private message" grains between two people. We haven't done this yet but we have some ideas.

Soon, I hope to see Rocket.Chat add a "single-channel grain" mode where its own sidebar is removed and it relies on Sandstorm's sidebar. This would provide better security for channels which should only be accessible to a subset of people. Probably, the multi-channel mode will stick around too, for cases where you want the same people to have access to many channels.

</comment></comment></comment></comment></comment></comment><comment><USER36> Scott Hanselman's interview with Kenton Varda about Sandstorm [2015]:

[http://hanselminutes.com/497/your-personal-cloud-platform- wi...](http://hanselminutes.com/497/your-personal-cloud-platform-with- sandstormio-and-kenton-varda)

</comment><comment><USER23> How do I report a bug in an app?

The email app Roundcube does not seem to support unicode characters in the senders name in received emails.

So the displayed name in received emails gets garbled if it contains e.g. a swedish character like 'å', 'ä', 'ö'.

<comment><USER3> In the Sandstorm UI, if you go to "Apps" and choose the app, you'll see a "report issue" link in the upper-right. Generally, these link to the GitHub issue tracker for the app or its Sandstorm packaging.

<comment><USER23> Thanks.

I have so far just tried the demo, but I find it surprisingly pleasant to use and well polished.

Impressive work.

</comment></comment></comment><comment><USER37> Any plans to support saving/loading grains to IPFS?

</comment><comment><USER38> always wondered by such projects. you have the resources, and you have made analogues of paid services, and that's cool, but what's next? I think you can offer people more than just a free Slack. Do you have any plan to integrate it with commercial products?

<comment><USER10> If you are asking how they will pay their bills: They offer a hosted version.

If you are asking if commercial software will be available: it already was from the start; draw.io is not open source but could i tefrate right away anyway.

<comment><USER39> draw.io has become unmaintained and unsupported.

<comment><USER10> Yep, but still proves my point that commercial apps were available from the start.

<comment><USER39> You mean proprietary and not commercial.

<comment><USER10> Ok, thanks for the correction.

Upvoted and appreciated.

</comment></comment></comment></comment></comment></comment><comment><USER40> I really like it but it seems it cant work on the old linux server kernel. PLEASE fix that

Thank you

<comment><USER3> Unfortunately this isn't feasible. Sandstorm requires some modern Linux kernel features to set up its sandbox. Kernels before 3.13 simply did not have the features necessary, and there's no alternative approach we can use to get the same effect. Sorry. :(

</comment></comment><comment><USER41> Looks pretty solid. Is there a comparison to other similar products like OwnCloud?

</comment><comment><USER42> Why is it an operating system? Looks like owncloud not like linux to me.

</comment><comment><USER43> I'll try;

</comment><comment><USER44> Previously on HN: [https://news.ycombinator.com/item?id=8972066](https://news.ycombinator.com/item?id=8972066)

As a marketer, I am all for launches, re-launches and marketing, but it's unclear to me what's different now compared to a year ago.

<comment><USER3> FWIW the submitter (who isn't affiliated with Sandstorm AFAIK) explains his reasoning here: [https://news.ycombinator.com/item?id=12104373](https://news.ycombinator.com/item?id=12104373)

But lots and lots has changed in the last year. :)

<comment><USER45> What's changed? I'm on your mailing list and I don't recall anything.

<comment><USER3> Well...

* Oasis (managed hosting) was launched less than a year ago.

* That came together with a huge UI overhaul that introduced the sidebar / tabbed UI.

* It also came with the full app market, whereas before we only had a static HTML app list.

* We started offering free SSL certificates for self-hosted servers under sandcats.io.

* We introduced Sandstorm for Work, which integrates with LDAP / SAML (including Active Directory) for login, offers organizational user management features, etc.

* We added app signature verification via Keybase, proving that apps came from the twitter/github/HN user you expected.

* We implemented app update notifications with one-click updates.

* We added signature verification to the installation and update paths for Sandstorm itself.

* We enabled apps to serve WebDAV APIs, which enabled Davros (a file sync app) and Radicale (a CalDAV calendar app).

* The community wrote / packaged 30 new apps, bringing the total to 58.

* We added the ability to link multiple login services to a single account.

* We implemented the Powerbox grain picker, which allows you to share a grain through another app. (This will begin being used in real apps in the next couple weeks.)

* We added unified notifications and read/unread indicators, so you can keep track of activity across your grains.

* Many other, smaller things. See: [https://github.com/sandstorm-io/sandstorm/blob/master/CHANGE...](https://github.com/sandstorm-io/sandstorm/blob/master/CHANGELOG.md)

<comment><USER10> Sneaking in a feature request here:

Can we have update descriptions for apps as well?

<comment><USER3> Yeah, actually, that wouldn't be too hard for apps that ship a changelog.

</comment></comment></comment></comment></comment></comment><comment><USER46> I forget, what's the name of this OS?

<comment><USER47> I think it's "Harder Better Faster Stronger"

</comment></comment><comment><USER48> Whaou I just realized for the first time that this company is named after the Darude's one and only hit.

<comment><USER3> For the record, I wasn't thinking of Darude's Sandstorm when I named the project. :)

EDIT: What I was thinking, at the time, was "sandbox in the cloud". But these days I like to retcon the name to be about granularity. Sandstorm's major technological innovation is fine-grained containerization, which is described in detail here: [https://sandstorm.io/how-it-works](https://sandstorm.io/how- it-works)

<comment><USER48> I will never believe it.

<comment><USER49> Grains of sand in a cloud is a sandstorm. Storms and clouds coming in are both said by people a lot. Synonymous in some situations. Some talk about sandstorms. It's believable that the connection was made without knowing... whatever work you're referencing. Never heard of it.

</comment></comment></comment></comment><comment><USER50> It supports too many apps/frameworks - It's too ambitious and not focused enough. Also, not all apps are the same when it comes to scalability - That's a false assumption which pretty much of all PaaS providers make.

There is more to scaling an app than just adding more machines - Services need to be scaled independently of each other based on usage; also, some services should run on their own dedicated hosts, some services require persistent storage also there are needs to be rules to define how services can talk to each other, recover from failures, etc...

Developers NEED some way to specify HOW their services should scale - It can't just be fully 'automatic' \- That's not flexible enough.

If you look at typical Kubernetes config files, they are quite long/complex; this is because there are a LOT of factors/variables involved when it comes to running services inside distributed containers and you can't just abstract away from those details without seriously compromising flexibility.

<comment><USER3> Sandstorm is not a PaaS and is not intended to be an alternative to Kubernetes. It is not designed for running SaaS services intended to scale to millions of users. It is designed for running personal or internal employee- facing services, where there are anywhere between 1 up to maybe 10,000 users. The kind of scaling you describe simply isn't an issue in this domain.

Moreover, Sandstorm takes a completely different approach to scalability called fine-grained containerization. The problems and solutions are really completely different from a Kubernetes-like approach. Read about it here:

[https://sandstorm.io/how-it-works](https://sandstorm.io/how-it-works)

<comment><USER51> Sandstorm is exciting to me for personal reasons. Scalability is not an issue there, because all my apps already need to run on only one computer.

Security and encryption is really important to me. Synchronization as well. Very excited about sandstorm because it seems to fix a lot of the gaps in my current flow.</comment></comment></comment>


Why the use of GPL is declining - <AUTHOR> http://dirkriehle.com/2013/04/13/a-dual-model-of-open-source-license-growth/ <comment><USER2> MIT and BSD are great for takers who like to take from open source and give nothing back since they are free to take the code, modify it, and release it as commercial closed source software (which is usually what happens). There are rare exceptions to this where people enhance and contribute back. Companies love MIT/BSD since they don't have to give back to their competitors.

The GPL is great as it ensures that everyone who uses my code has to give their contributions back so I get to use and improve upon it, too. Individuals usually like this. Companies often do not.

The way I look at it, I'm doing work for free. The GPL ensures I get a return on that investment in the form of additional code and work that I can use in my own projects and that everyone can benefit from. MIT/BSD lets someone else profit from my work without giving anything back to anyone.

<comment><USER3> So why is it that Apple, Google, etc are contributing a lot of code back to llvm/clang when they don't have to? Why is it that no one's created a long- lasting fork of xfree86/xorg, even though those are also under permissive licenses? Why is it that there are many commercial consulting companies for PostgreSQL that donate everything they write back to the community? Conversely, why is it that MySQL under Oracle, while GPLed, is criticized for not being open and contributing meaningful information about the project?

<comment><USER4> because working publicly on software is the right way to make software. Try explaining that to a middle aged balding manager who just wants to get through the next quarter without getting canned. You can make an easier case to use permissive software, and once you're using it you can make an easier case to submit public work.

To me, that says we need more pressure, not less.

<comment><USER3> I'd argue that history shows otherwise. GPLv3, with its increased restrictions, proved a bridge too far for a lot of projects, to the detriment of everyone. Apple, the FreeBSD project, the OpenBSD project, etc have all put in efforts to divest themselves of GPL encumbered code because it increased the costs of using the software. Because the wording of things like the patent clauses were so questionable, it became much cheaper in terms of lawyer time, etc, to either use older software that was still under GPLv2, or to use software using less-encumbered licenses, like BSD and MIT.

That balding middle manager needs to make sure that that license is acceptable by his boss, by the people in the legal department, etc. For example, an innocuous throwaway line of a program that can only be used for "good, not evil," ends up needing to get the lawyers involved for clarification and special waivers ( <http://dev.hasenj.org/post/3272592502/ibm-and-its-minions> ). If the internal costs of using an encumbered program are too great, then chances are, it just won't get used; the company will either write their own version, or use a commmercial variant.

<comment><USER4> That's well argued. Truth be told IANAL, I know the GPL has being patched to avoid people shirking it's intention. If it became a bit of a monster because of that, I would not be aware.

</comment></comment></comment></comment></comment><comment><USER5> For me, the thing which killed the GPL was the GPL v3.

Not the contraversy which surrounded it, but the fact that GPL v2 is incompatable with GPL v3, and the suggested fix was "make your licence GPL v2+ and trust us for all time to never make a licence you disagree with". I am aware of several projects which will probably never get off GPL v2, and now can't merge in GPL v3-only code (as while the FSF seem to encourage people to make the code forward-licence compatible, they don't seem to encourage backward-licence compatability).

For me (and several minor projects I work on), that was the point at which we just threw our hands in the air -- we didn't have the time or motivation to pick our way out of this situation.

<comment><USER4> Now _that_ is a valid criticism.

The FSF drives a hard line sometimes, frankly I think more ire should be directed at TiVo than FSF. The uppity jerks.

<comment><USER6> > The FSF drives a hard line sometimes, frankly I think more ire should be > directed at TiVo than FSF.

In the first place, IMO, "Tivoization" is an overblown problem ; in the second place, I think the anti-tivoization (and, insofar as they limit the use cases of Free Software, anti-software freedom) provisions of the GPLv3 have done more to prevent GPL usage than to prevent tivoization.

I think it dramatically highlighted the problem with the GPL approach: that, now that the value of open source software is demonstrated, while some people _will_ take and not give back with the opportunity, lots will, and you end up getting more growth of usable F/OSS software if you don't burden the people downstream, and if you try to use compulsion, you get locked in a cycle of increasing the complications and restrictions for downstream users in a way that just gets more people to throw up their hands and not bother with your code at all. While the bad actors find new and creative ways of complying with your most recent license while subverting its intent, leading to yet more complicated licenses, with more burdens, etc.

<comment><USER7> The funny thing is, in a way, Stallman and Apple agree: users should be able to modify and enjoy their devices any way they like. For the hackers, that means root access. For normal users, that means being able to install apps without worrying about security and privacy. The Stallman model drives the internet's infrastructure, but the Apple model now drives consumer computing. We can argue about the particular provisions (I do prefer Android), but apps work.

I think the GPL was a legal solution to a social problem: companies were hoarding software and trying to patent it. But software patents are still illegal in most of the world, and the best way to ensure software cannot be patented is to publish it under a permissive license, and demonstrate prior art. Regardless of intent, licensing something under GPL is a kiss of death in certain cases, so it acts a bit like a patent anyway: it scares away commercial competitors.

Tivoization is also interesting, because we sort of have a modern day Tivo: Netflix. It's so convenient and affordable, people don't care how the video is being delivered. Instead of Tivo hacking, there's the Netflix API. (<http://developer.netflix.com>)

The fact is, software- and content-as-a-service have largely made the GPLv3 irrelevant, because the goals it's meant to enable, i.e. freedom and accessibility of software, have been realized in different ways. Society at large simply does not care about a Grand GPL future. It does care about privacy, and being able to export their data from the services they sign up for.

</comment></comment></comment></comment><comment><USER8> You know, if I make something open-source, it's because I _want_ people to use it. I refuse to use copyleft licenses because all they manage to do in practice is ensure no commercial venture will ever use your code. If I didn't want a commercial entity using my code, I wouldn't make it open-source.

The GPL was created to help _free software_ , which is more about freedom of speech, not open-source. It should be used only when your code is intended as a contribution to the free software movement, not when it is intended to simply be open-source.

<comment><USER9> right, like for example Git. No one has built any commercial ventures around Git that I know of.

<comment><USER10> Are those commercial ventures linking their code with the Git binary? Or are they just building tools which wrap the command-line Git tool?

I'm inclined to think that most (if not all) commercial offerings are going to use the second option, because there won't be much difference to the end-user and it means the company won't have to open-source their code. If Git was permissively-licensed, perhaps those companies would choose to link with the binary (or incorporate the code directly into their products) and contribute patches and bug-fixes back to the project.

<comment><USER9> perhaps, I think it's some what of a myth that one can't make money from free software. Sure one can't erect flimsy toll booths and extract rents but as I look around I see lots of companies, .eg. IBM profiting quite nicely from free software.

</comment></comment></comment></comment><comment><USER11> When I find BSD or MIT licensed code, I feel like a kid whose grandmother has given him money for his birthday, so he can spend it on what he wants.

When I find GPL licensed code, I feel like a kid whose grandmother has given him underpants for his birthday.

<comment><USER12> This is exactly my feeling! A lot of my "playground stuff" is in the Public Domain for this very reason; I hate giving underpants as gifts cause that is _such_ a bummer (and you don't even find out a lot of times until you download the bloody thing), I can't even explain just how bad it feels without coffee first.

The non-playground stuff is MIT (something I did for work) or ISC, which is mostly harmless to anyone who wants to actually _use_ it. People who use GPL are too hung up on controlling the distribution mode of derivatives; I understand the reason GPL exists, but I think it's a faulty premise to begin with.

Kinda like Peace Through Superior Fire Power.

Also, the preamble to the GPL reads a lot like religious/political rhetoric.

<comment><USER13> Would you care to elaborate why you think GPL's premise is false?

And I believe you're right, the GPL is (and was designed to be) a political statement.

<comment><USER12> I started writing a reply and then I just remembered I wrote about how I felt about it a little while back.

<http://eksith.wordpress.com/2008/11/24/gpl-vs-bsd/>

On three separate occasions so far, I've come across a situation where someone has rejected a GPL piece (with basically nothing wrong technically; which is a damn shame) only to go with BSD the first time, ISC the second and, to my surprise, a closed source solution the third. Now 3 may not seem like a statistically significant number, but from the type of projects these were, my feeling is that the GPL seems to actively repel adoption to the point where even a closed source binary is more preferable.

The premise is to ensure quality code gets returned to the community, and I understand that, but quality code isn't what we usually get back. When the issue is forced, by and large, I feel people reject participation entirely, return the bare minimum necessary to comply (let's say an API which is GPL licensed while the rest of the library/application is under a different one) or, of course, non-compliance.

It's hard not to be a cynic these days, but I do think most people are basically good. And if you give good people the choice of doing good, they will not only do it, but also do it more earnestly. This earnestness in turn will produce, I believe, code of the best quality.

</comment></comment></comment></comment><comment><USER14> GPL restricts my freedom in an effort to protect it. BSD and MIT and other licenses like them carry no such restriction.

<comment><USER4> wow. I honestly thought that when I heard that argument on 4chan, that the people on the other end making that argument were aware how crazy their line of thinking was. This was the last place I expected to see that sentiment reiterated.

You live in a society of laws, that guarantees your freedom. BSD and MIT do not guarantee your freedom. They are free in a purely anarchist sense. This is not a good thing™.

<comment><USER15> What stcredzero says is logically right: it restricts the freedom for contributing and licensing your own work in the next hop.

I am not saying that GPL is bad, I am arguing that in complex scenarios this is not the right choice.

<comment><USER4> I don't know if the situation is really that complex. The GPL and it's code base exist to push the world towards the correct state of being.

That feeling of wanting to use a GPL library, but not being able to open source your code feels awful, I know, but that feeling is there to get you to ask "Why cant I open source my code?" not "Why is the GPL restricting me?"

<comment><USER10> I've released all of my open-source code -- with the exception of one project (LGPL, because it was a direct port of another LGPL'd library) -- under permissive licenses like Apache 2.0 or modified BSD.

What I really dislike about that feeling you describe is when I think of a good project I'd like to build, but which would require the use of a GPL'd library -- therefore requiring me to license my code under the GPL. Every time that's come up, I've just opted not to create the project; in my mind, I just can't justify writing open-source code that's "free" instead of free.

</comment></comment></comment></comment></comment><comment><USER16> Nowadays in the wide I mainly see two use cases for GPL code, either the person want to limit its use to encourage purchase of a commercial license or to prevent its use by a conccurrent, or the second use I see is people wanting to make a political statement of some sort.

I respect both use cases but ultimately I consider GPL code more like teasing to me, because as great as this code is, I know there is some limitations with this code and I won't be able to use it as freely as I'd want now or in the future.

So now, to spare me the mental pain of knowing there is a great GPL project I know I can't use, the first thing I do when I discover a new project is to check its license and if it's GPL I stop reading, plain and simple. I highly respect people releasing GPL code, I highly respect their motivations and somehow their political engagement but I treat it like if this code didn't exist or is a binary.

And for my own code I use the MIT License when I choose to share it with the world.

</comment><comment><USER17> I decided to use MIT license, because it's permissive and simple enough.

<comment><USER18> Most of the work I release is licensed using MIT because it allows other developers to build with my code without limitations or requiring full attribution. I like the idea of anybody having direct access to change or update what I've written to make it better, faster, cleaner.

Until I can find a more "free" license I will stick to MIT as well.

<comment><USER19> <http://unlicense.org/>, <http://en.wikipedia.org/wiki/WTFPL>

<comment><USER20> Please don't. Licenses like MIT, BSD 2-clause, etc. are all well-understood by people in the legal profession at this point, while these really add nothing to the table. There's no need for the proliferation of open source licenses.

</comment></comment></comment></comment><comment><USER21> Although there may be altruistic or political reasons for preferring MIT/BSD/Apache style licenses over the GPL, I believe that the choice of license must be closely related to the type of project you are creating. If the project is a library or a piece of code that is intended for use by other developers, you will greatly increase the potential audience for your project by using a license like the MIT/BSD or Apache license.

If however, your project is a complete application (say a code editor, browser, or a game), whose primary audience consists of non-developers, then a GPL can be a good license, as it maximizes reach to your intended audience, while still allowing developers to contribute the project, and most importantly preventing free-riding by potential competitors.

</comment><comment><USER22> Sometimes I don't care about rights. I care about results.

Considering market size, # of active developers, and general amount of funding (corporate or otherwise), which is the best/most advanced, a major Linux distro or FreeBSD?

The answer to this question will tell you which license has better results.

<comment><USER10> > The answer to this question will tell you which license has better results.

Correlation does not imply causation.

[https://en.wikipedia.org/wiki/Correlation_does_not_imply_cau...](https://en.wikipedia.org/wiki/Correlation_does_not_imply_causation)

</comment></comment><comment><USER23> I don't expect anyone here arguing for the GPL (in an predominately neoconservative community like hacker news). So anyways, I make the conscious decision to use GPL, because it protects my work from exploitation by others (corporations are people too my friend, right?)

<comment><USER24> I am absolutely amazed by the reactions in this thread. I don't know if HN readers are bunch of neo-cons (I'm certainly not), but I wonder if people feel threatened by the GPL, because they are current or aspirational entrepreneurs who think the GPL gets in the way of their making a lot of money.

<comment><USER10> I don't think HN readers in general are neoconservative, mostly quite the opposite.

I do, however, think many HN readers have a strong libertarian streak. In this case, when I say "libertarian", I mean true libertarianism (not the "tea party"-ish faction of the Republican party).

In this respect, I imagine most HN'ers prefer the BSD/MIT/Apache 2.0 licenses not because they want to make money off of free software in the future, but because they value personal freedom and extend those beliefs to their own software development. In other words, they want to use free/open software to avoid being trampled on by some company, but they're also not OK with being pushed around by any other "free" software developers.

Read a bit of this article and you'll see what I mean:

<https://en.wikipedia.org/wiki/Libertarianism>

<comment><USER24> "when I say 'libertarian,' I mean true libertarianism . . ."

Talking about "true libertarianism" is no different than talking about "true conservatism," "true feminism," "true Marxism" or anything else -- these terms are all historically fluid, and accusing one another of not being "true" is one of the main activities among communities who unite under the supposed unity of an ideological stance.

Richard Stallman, it should be noted, has also been called a libertarian (<http://actonline.org/act-blog/archives/1147>).

But yes, you're probably right in the main about their not liking to be pushed around by others. Still, that describes a vast cross-section of human society.

</comment></comment></comment></comment><comment><USER14> Another way to think of this: It's alright if you've brought the toys, and you feel the rules to play should be a certain way. It's also alright if you insist on those rules and decide to take your toys home if you don't get to play by those rules. This is pretty much what the GPL is. When it gets obnoxious, is when people start saying that you're "evil" for not using your favorite rules. That's possible, particularly when the complexity of the real world brings pragmatism into play, but it is a bit of an extraordinary claim, especially when put in absolutist terms.

That would be like saying that you're "evil" for playing any kind of ball game without a helmet. This could be a highly beneficial and pragmatic thing in one context (professional baseball) but just silly and obnoxious in another. (Sandlot game with a wiffle ball.)

Stallman and the FSF make the claim that there is a new set of human rights concerning software that we weren't aware of before. That is the crux of the matter. Is it enough to let everything play out "in the marketplace" and let people vote with their dollars and their feet, or is there a new set of rights that should be enshrined in law?

I do think Stallman has a point, and that much good has come of copyleft and activism by the FSF, but does this give someone a right to declare what is absolutely good and evil? I don't think so.

</comment><comment><USER25> i use MIT for almost all my code these days, because I tend to work in javascript, and it just feels like MIT/BSD is the natural license of the web.

To even try and restrict what others can do with code that I send to their browser to have it work in the first place, feels dumb.</comment>