Shoulders of giants

If I have seen further it is by standing on the shoulders of giants.

Isaac Newton, in a letter to Robert Hooke, 1675

Newton did not say where he found that line. It was already five centuries old: in 1159 John of Salisbury wrote that Bernard of Chartres used to say we are like dwarfs sitting on the shoulders of giants, and it took later scholars to trace the thread back that far. Credit is easy to lose along the way. The Lolly project strives to honour attribution, provenance and all the legacies it builds on.

If you are new to how software is made, start here: almost nothing in the apps you use every day was written from scratch by the company whose name is on the box. It is assembled from parts that thousands of people wrote, tested and gave away, some of them decades ago, most of them strangers to each other. Lolly is a few years of work standing on several decades of theirs.

Lolly signs what it makes; this page credits what it is made from. The legal record, with every licence in full, ships inside every copy of the app and is linked at the end.

How world-class software is really made

Open source is a simple arrangement with large consequences. The authors publish their code under a licence that lets anyone read, use, change and share the code. Most of those licences ask one thing in return: that you say where the work came from. Some, called copyleft licences, ask more: if you share a changed version, you share it on the same terms, so the work stays open wherever it travels. A few ask nothing at all.

It sounds like charity, and mostly it is not. Companies pay engineers to work in the open because a shared foundation, maintained by everyone who depends on it, is cheaper and better than a private one that each of them would have to build alone. Volunteers give their evenings because building something useful beside people you respect is one of the more satisfying things a person can do. Most of the projects on this page are a mixture of both.

The scale is hard to picture. In 2024, economists at Harvard Business School estimated that writing the world's widely used open source software once more would cost about $4.15 billion, while its value to the firms that use it is about $8.8 trillion; without it, firms would need to spend 3.5 times more on software than they do. The gap between those two numbers is the whole argument: the work is paid for once and used everywhere. What no study prices as easily is the social side: people in different countries and companies, most of whom will never meet, reviewing each other's work and fixing each other's mistakes in public.

He who receives an idea from me, receives instruction himself without lessening mine; as he who lights his taper at mine, receives light without darkening me.

Thomas Jefferson, in a letter to Isaac McPherson, 13 August 1813 (The Writings of Thomas Jefferson, volume 13)

Jefferson was arguing that an idea is hard to own, because giving it away costs the giver nothing. He never saw software, and software makes his case more plainly than a candle does: a copy costs almost nothing to make, and whoever shares it still has the original.

Everything that follows is a stack of shared work, with Lolly at the top. The rest of this page climbs it from the bottom.

Open this in Diagram Builder

Where it starts: GNU, Linux and Kubernetes

In September 1983 the GNU project set out to build a complete operating system that anyone would be free to use, study, change and share. Its compiler, GCC, arrived in 1987, and in 1989 its General Public License made that sharing a legal rule: change the code and pass it on, and you pass it on under the same terms.

In August 1991 a student in Helsinki, Linus Torvalds, posted a note about "a (free) operating system (just a hobby, won't be big and professional like gnu)". Within a few months his kernel was under the GPL too, and together with GNU's tools it made a complete free system, the one most people now simply call Linux. It was not meant to be big.

It now runs all of the world's 500 fastest supercomputers, most of the servers behind the web and, as the kernel inside Android, most of the world's phones. Each release is the work of a crowd: 2,038 people contributed to Linux 6.17, 298 of them for the first time.

Kubernetes came later, and from a company. Joe Beda, Brendan Burns and Craig McLuckie started it at Google, drawing on the company's long experience of running software in containers. Its first public commit went up in June 2014, contributors largely from Google and Red Hat carried it to version 1.0 in 2015, and Google then gave it to the newly formed Cloud Native Computing Foundation to be run in the open.

It is now one of the largest open projects there has ever been, and it is how a great deal of the world's software is deployed, Lolly's own web container included.

SUSE: the first enterprise Linux business

Lolly began at SUSE, so this part of the story is close to home. SUSE is one company among many that work this way: Kaleidos, Canonical, Collabora, Igalia, Arm, Intel and hundreds of others pay people to work on code everyone shares, and none of it would stand without the volunteers beside them. We have kept this part to things you can check.

SUSE was founded in September 1992 in Fürth, Germany, by Roland Dyroff, Thomas Fehr, Hubert Mantel and Burchard Steinbild, and shipped its first Linux product in 1994. In 2000 it launched SUSE Linux Enterprise Server, which SUSE describes as the first globally distributed, fully supported Linux server operating system for enterprise production environments, and SUSE calls itself the world's first provider of an enterprise Linux distribution.

It is one of the oldest Linux distributions still maintained, and since 2005 its community edition has been openSUSE.

What a company like SUSE gives the world is easy to miss, because most of it is not a product you can see. It pays people to look after the parts everyone else depends on, and their names are in the files where Linux and GCC list who maintains what:

• Sound. Takashi Iwai co-maintains the Linux sound subsystem, ALSA, and appears under SOUND in the kernel's list of maintainers. If audio plays on a Linux machine, his work is in the path. In LWN's count for Linux 6.17 he was the third most active of all 2,038 contributors.
• The kernel's core. David Sterba maintains the Btrfs file system. Jiří Kosina and Jiří Slaby built kGraft at SUSE in 2014, and live patching, which updates a running kernel without a restart, is now part of Linux, with SUSE engineers among its maintainers. Greg Kroah-Hartman spent seven years at SUSE and Novell looking after the stable kernel before he became a Linux Foundation Fellow in 2012. In LWN's count for Linux 6.17, SUSE was the sixth most active employer by changesets and the fifth by lines changed.
• The compiler. Richard Biener is one of GCC's global reviewers and maintains its middle end, its vectoriser and its link-time optimisation, as GCC's own list records. Jan Hubička started GCC's call-graph module as an experiment at the first SuSE Labs conference, and has worked on link-time optimisation since 2010.
• The desktops. Federico Mena Quintero co-founded GNOME with Miguel de Icaza in 1997, and today works at SUSE, where he maintains librsvg, the library that draws SVG pictures across the Linux desktop. Stephan Kulow coordinated KDE's releases while at SUSE, and later ran openSUSE's. SUSE is a Patron of KDE and sits on the advisory boards of both the KDE and GNOME foundations.
• The office suite. Michael Meeks worked on GNOME, Evolution and OpenOffice.org at Novell, SUSE's owner from 2004 to 2011, and was, in LWN's words at the time, at the heart of the effort that launched LibreOffice and The Document Foundation in 2010.
• Tools that build other people's distributions. The Open Build Service builds packages for many distributions from one source, and the OBS project lists Tizen and VideoLAN among those running their own. openQA, which tests an operating system by watching its screen the way a person would, began in the openSUSE community in 2011; Fedora adopted it after SUSE's Richard Brown got it running on Fedora during a SUSE Hack Week.
• Kubernetes and the edge. Since 2020 SUSE has been home to Rancher, whose co-founder Darren Shepherd built K3s: Kubernetes light enough to run on small computers at the edge of a network, far from any data centre, and a CNCF project since 2020. The Longhorn storage system is a CNCF incubating project, Harvester is open too, and the NeuVector container security platform was opened to everyone in 2022, soon after SUSE bought NeuVector.

Our favourite example is a small one. Around 2007, Michael Schröder began writing libsolv at SUSE: a solver that works out which packages a system needs. It is the engine inside openSUSE's package manager, and it is also inside Fedora's DNF and, through mamba, inside conda, which made it the default in 2023. Communities that compete for the same users all rely on one piece of code, and each of them is better for the sharing.

Open this in Diagram Builder

The free desktop came first

The assumptions Lolly is built on (render on your own device, keep your files yours, treat Linux as a first-class home) were the working assumptions of the free software desktop long before this project existed. The deepest code in the app grew up there.

HarfBuzz shapes every run of text that Lolly turns into vector outlines, so an exported SVG or PDF reads the same on a machine that has never seen the font. Its oldest code began inside FreeType in the late 1990s, grew up in GNOME's text stack (Pango) and in Qt, and was unified by Behdad Esfahbod under freedesktop.org. The same shaper sits inside Chrome, Firefox, Android and LibreOffice, and Lolly runs that same code, unchanged, in the browser and on the command line; the section on WebAssembly below explains how. The name is Persian for "open type".

Open this in Diagram Builder

• eSpeak NG is the voice under the voice. Jonathan Duddington wrote its ancestor, Speak, for Acorn machines in 1995; eSpeak reached Linux in 2006 and became the sound of the free desktop's screen readers. When Lolly's neural voice reads text aloud, eSpeak NG, compiled for the web by the phonemizer project, first works out how every word is pronounced. So a speech synthesiser from 1995 now tells a neural voice from 2025 how to say "Worcestershire".
• GIMP, the image editor Spencer Kimball and Peter Mattis released as Berkeley students in 1996, is owed a different kind of thanks. No GIMP code runs inside Lolly; instead Lolly writes GIMP's own XCF format from scratch, so a layered export opens straight into GIMP. GTK, the toolkit GNOME is built on, began life as GIMP's toolkit.
• KHTML, begun in the KDE project in the late 1990s, became WebKit, which became Chromium's Blink. Lolly's desktop app renders through WebKit on Linux and macOS and through a Blink-based view on Windows, and the command line's high-fidelity renderer and this site's own screenshots run headless Chromium, so every one of them has a KDE ancestor.
• D-Bus and the XDG desktop portals, freedesktop.org's shared plumbing, are how the Linux build behaves like a native citizen: the screenshot and wallpaper portals, and search providers so GNOME Shell and KRunner can find your tools by name.

Open this in Diagram Builder

Lolly ships as openSUSE RPMs and a Flatpak and registers with the desktop's own search, so the platform that taught this project its values is also one of its homes.

Design in the open: Penpot, Inkscape and Blender

For most of the history of desktop computing, the tools professional designers and animators worked in were closed and expensive. Three open projects did a great deal to change that.

Penpot is made by Kaleidos, a company in Madrid whose co-founder and CEO is Pablo Ruiz-Múzquiz. It began life as UXBOX, which Kaleidos first showed at FOSDEM in Brussels in 2020, released its first public alpha in February 2021 and reached version 2.0 in April 2024, and its source is under the Mozilla Public License 2.0, the licence Lolly uses too.

Its file format is open, which is why Lolly can open a .penpot file as an editable design and write one back out, and why the two share the design token format drafted by a W3C community group. Lolly's own export plugin for Penpot signs what it exports with Content Credentials. Penpot's newest renderer runs on WebAssembly, the same technology that carries most of Lolly's older code into the browser.

Inkscape is older, and its family tree reaches back further still. It began in 1999 as Gill, the GNOME Illustrator, written by Raph Levien; Lauris Kaplinski led its successor, Sodipodi; and in 2003 four Sodipodi developers, Bryce Harrington, MenTaLguY, Nathan Hurst and Ted Gould, started Inkscape, whose source is on GitLab. Version 1.0 arrived in May 2020.

For more than twenty years it has kept SVG a format working designers use every day rather than a specification on a shelf. Every SVG Lolly writes opens in Inkscape with its paths intact, Lolly's GIMP palette export loads straight into it, and when you inspect an SVG in Lolly's Verify, the Inkscape version that made it is one of the things it reports.

Blender nearly did not survive. Ton Roosendaal started the Dutch animation studio NeoGeo in 1989 and wrote the first source files called Blender on 2 January 1994, a date still counted as Blender's birthday. He later founded a company, Not a Number, to develop it, and when that company closed in early 2002, development stopped and the code belonged to its investors.

Roosendaal set up the non-profit Blender Foundation and in July 2002 launched a campaign called Free Blender. Blender's community of around 250,000 users raised €110,000 in seven weeks, enough to buy the code back, and on 13 October 2002 Blender was released under the GNU General Public License. Software that would have died with its company was saved by the people who used Blender every day.

Then Blender set out to show what open tools could do. Elephants Dream, made under the codename Project Orange and released in 2006, is widely recognised as the first open movie: the film and every asset used to make the film were published under a Creative Commons licence. Big Buck Bunny (2008), Tears of Steel (2012), Spring (2019) and Sprite Fright (2021) followed, and each production pushed new features into Blender itself. Those films showed the world that design and animation of the highest standard could be made with open source tools. Lolly's scene-linear OpenEXR export is written for tools like Blender, which read that format natively.

In 2019 Roosendaal and Blender received the Ub Iwerks Award at the Annie Awards. On 1 January 2026, after more than thirty years with Blender, he handed his roles as chairman and CEO to Francesco Siddi, with Sergey Sharybin, Dalai Felinto and Fiona Cohen joining him on a new board. Roosendaal leaves a legacy, as so many in open source have: a tool that belongs to everyone, and a new generation to carry Blender forward.

Where free graphics grew up

The projects on this page did not grow up alone. In March 2006 the first Libre Graphics Meeting opened in Lyon, France, co-founded by Dave Neary and Dave Odin so that the people behind GIMP, Inkscape, Krita, Scribus and Blender could spend a few days in one room each year. It has met most years since, from Montreal and Wrocław to Brussels and Vienna, so that those projects can work across their borders: on shared file formats, on brushes and on colour management.

Creative Commons was part of that world early. Jon Phillips, known as rejon, worked as a community developer at Creative Commons and helped make clear licensing a normal part of free graphics work, the early groundwork for the credits and provenance Lolly records today.

Other rooms mattered as much. GUADEC gathers the GNOME community every year. FOSDEM fills a university campus in Brussels every February. In Australia there is linux.conf.au, where Linus Torvalds has often been in the audience; at the 2009 conference in Hobart he took garden shears and then clippers to Bdale Garbee's beard after an auction raised more than A$36,000 for research to help Tasmanian devils. Bdale Garbee, then HP's open source and Linux chief technologist, was one of several people who took a personal interest in seeing a future for free creative software come true, and whose support made much of this possible.

Some people make everyone around them better. In Melbourne, Peter Moulder (pjrm), Michael Wybrow and Nathan Hurst shared a research lab at Monash University. Andy Fitzsimon, who started Lolly, visited them there, and they worked well together. lib2geom, the geometry library under Inkscape, began as a collaboration between Inkscape developers and Monash's graphics researchers, and Nathan Hurst, one of Inkscape's four founders, is among its main authors. Michael Wybrow's libavoid routes the connectors Inkscape draws between shapes, and Peter Moulder, after years of research on diagram and text layout, joined YesLogic to develop Prince for Books.

Carl Worth co-founded cairo with Keith Packard: the 2D graphics library that GTK and Inkscape have drawn with for years, and that drew both the pages and the interface of Firefox from version 3). He spoke at linux.conf.au more than once, came to meetings like these, and shared what he knew about vector graphics with every project that asked.

At GIMP, Manish Singh (yosh), who made GIMP's early releases, was friendly to every new contributor and steered the expertise they brought into the code. Michael Natterer (mitch) and Sven Neumann carried GIMP as its maintainers for years, and Øyvind Kolås (pippin) built GEGL and babl, the image and colour engines that give GIMP high bit depths and non-destructive editing.

The designers came too. Jakub Steiner (jimmac), who drew most of the Tango icon library and much of GNOME's look, Hylke Bons, who started SparkleShare so designers and developers could share their work, and Garrett LeSage, a designer in free software since the late 1990s, brought a designer's eye to GUADEC, FOSDEM and meetings like these while the foundations were still being built. Jakub and Garrett both worked at SUSE along the way.

There are far too many to name. People like these are force multipliers: a welcome, an answer or a drawing at the right moment makes a whole project better, and the work of everyone who follows travels further. What free creative software has become, it owes to all of them.

Open fonts, shared with the world

Raph Levien, who created Gill, also gave type designers Spiro, a toolkit for drawing curves, and readers Inconsolata. Dave Crossland has spent years making the case for free fonts and helping designers publish them. Their work met at Google: at the 2010 Libre Graphics Meeting, Dave presented the font sponsorship initiative Raph was leading, funding typefaces that people could share and improve together. They helped build the tools, funding and community that made open fonts a practical choice for designers everywhere.

That work reached Andy Fitzsimon too. He played a part in commissioning and open-sourcing Outfit, Overpass and the SUSE type family. Open licensing was the starting point: the ecosystem Raph, Dave and their fellow contributors had built made sharing the natural choice. The type designers deserve their own credit: Rodrigo Fuenzalida for Outfit, the Overpass design team for Overpass, and René Bieder for SUSE and SUSE Mono.

On 28 September 2026, Google Fonts' analytics counted more than 125 trillion font views served in total, among them 91.9 billion for Outfit, 72.0 billion for Overpass, 595 million for SUSE and 17.2 million for SUSE Mono: views served, not people, and only one of the ways an open font is used. A typeface commissioned for one organisation can become part of everyday reading across the world.

Lolly owes Raph and Dave a particular thank you, alongside the designers and maintainers who keep that work open. The freedom to choose, use and share good typography is part of what makes a tool like Lolly possible.

Data that tells a story: D3

D3 is the clearest case on this page of a small project changing a whole profession. Mike Bostock published it in 2011 with Jeff Heer and Vadim Ogievetsky at Stanford's visualisation group, as a way to bind data directly to the shapes on a web page (the paper). Bostock then spent several years as a graphics editor at The New York Times, and newsrooms around the world took D3 up for the charts and maps that carry a story. When it received the Information is Beautiful Test of Time award, the citation said it had "changed how millions of data visualizations are created across newsrooms, websites, and personal portfolios". In Lolly, D3 draws the Chart tool, projects the street maps and spins the meeting planner's globe, and Observable Plot, a younger library built on it, draws the Chart tool's statistical and editorial forms.

The catalysts: WebAssembly, WebGPU and generative AI

Most of the giants above wrote for desktop computers, in languages like C and C++, long before anyone expected a web page to do serious work. Three newer technologies are why Lolly can draw on them at all, and why a small team can reach for the best solution in each field rather than the nearest one.

WebAssembly carries old code into the browser. Alon Zakai, then at Mozilla, created Emscripten, a compiler that turns C and C++ into something a browser can run; his asm.js work with David Herman and Luke Wagner showed that it could be fast. In June 2015, Mozilla announced, together with engineers from Chromium, Edge and WebKit, a proper binary format for it, and WebAssembly became a W3C Recommendation in December 2019. It is why HarfBuzz, eSpeak NG, the C++ port of the ZXing barcode reader, JPEG XL, libopenmpt and ONNX Runtime run inside Lolly unchanged, in a browser tab or in the terminal, on any operating system and with nothing to install.

WebGPU gives the page the graphics card. For most of the web's life a page could use the GPU to draw, but hardly to compute. WebGPU, written by the W3C's GPU for the Web Working Group, changed that: it shipped in Chrome 113 in 2023 and began reaching Firefox and Safari in 2025. It is why Lolly can enlarge a photo, cut out a background or reword a sentence on your own graphics card, inside the page, with nothing sent to a server, and the web app now needs it to start (Supported environments).

Open this in Diagram Builder

Generative AI is the catalyst people argue about most, and it has earned both the excitement and the caution. It reaches Lolly in two ways. The first is the open models in the next section: research groups and companies that published trained models for anyone to run. The second is how Lolly was built. It was developed with AI-assisted coding and discovery, with a person setting the architecture, curating the code and directing the experience.

Those assistants learned from public code and writing, much of it open source, and not everyone who published that work agreed to this use. An assistant is only as useful as what it has read, and what it has read is the open code, open documentation and patient answers to strangers' questions that millions of people published over more than thirty years. Lolly credits every part of that work it can trace.

The new giants

The newest giants are neural networks that research groups and companies trained, often at great expense, and then published for anyone to run. Lolly runs them the way it runs everything else: on your device, downloaded only when a feature needs them, pinned by checksum in the build, each model family carrying its own credits file. OpenAI's Whisper turns speech into text with word-level timing, which is what lets you edit a video by editing its words; Kokoro, an 82-million-parameter voice published by hexgrad in 2025, reads text aloud. Hugging Face, where most of these models are shared, and the runtimes that carry them into the page, ONNX Runtime and transformers.js, are the common ground under all of them. The full list is under Everyone else inside Lolly, below.

Stronger together

Put the dates side by side and a pattern appears. Each bar below runs from the year a project began, or began in the open, to today, because every one of them is still maintained. Green marks work started by volunteers, students and university labs, blue work started by companies, and amber work begun among the browser makers and the W3C. Each generation builds on the last, the three take turns carrying it, and Lolly's own bar, at the bottom, has barely begun.

Open this in Diagram Builder

Not everyone on this page shared for the same reason. Some chose to, because they wanted their work used. Some were paid to, because their employers were better off with a foundation everyone maintains. And some were required to, because the code they built on came with a copyleft licence: KHTML was under the LGPL, so the changes Apple made to it had to be published too. The reasons differ and the result is the same. People they would never meet, in countries they might never visit, built on the work and gave something back. That is how a speech synthesiser written for an Acorn computer came to guide a neural voice, how a web engine begun by KDE volunteers came to sit in the browsers on billions of phones, how a solver written for one Linux distribution came to serve its competitors, and how a 3D suite that closed with its company was bought back by its own users.

We are all stronger for the sharing. An idea given away is not lost, and in many hands it travels further than any one of us could carry it alone. Projects come and go, and the ones that endure are used every day by people who may never know their names.

Lolly is one more place those ideas have reached, and, under the same terms, one more place they can leave from. In 1932 the typographer Beatrice Warde wrote that from a printing office "words may fly abroad". Lolly took her line as its motto, and changed one word.

From this place ideas may fly abroad

Everyone else inside Lolly

The story above had room for only some of the names. Here are the rest, grouped by where their work runs in the app.

The full text of every licence

Curation is not the record. The record is:

• THIRD-PARTY-LICENSES.txt, inside every copy of the app: the bundled components with their complete licence texts.
• THIRD-PARTY-NOTICES.md, the notices for vendored assets, in the repository.
• sbom.cdx.json, a CycloneDX software bill of materials for the npm and Rust dependency graphs, more than 1,400 components long.
• Credits files beside every downloaded model family, a credit line inside every emoji set, and notice files beside vendored assets.

Lolly itself is open source under the Mozilla Public License 2.0. Mitchell Baker wrote its first version in 1998, when Netscape decided to publish its browser's source code, and version 2.0 followed in 2012. The whole of Lolly is on GitHub.

If your work is inside Lolly and credited wrongly here, or not credited at all, tell us and we will correct the record. Most open projects ask to be credited, some ask for more, and a few ask for nothing at all. Lolly honours what each licence asks, and gives credit even where none is asked.