What are your favorite examples of elegant software?

Not sure if games count as software but if they do - Factorio. I don't play much these days but I'm still utterly stunned how a relatively small, humble team of developers can build something so robust and performant. Granted, I've never really tried pushing the limits, but not once have I felt like the game is even breaking a sweat while processing thousands of machines, belts, and bots. It's a miracle to me.

Their devblogs are really nicely written and you can tell they are extremely passionate about getting things right. In my experience that's a rarity now.

And of course, it's a brilliantly addictive game.

Emacs - although there's a lot of accumulated cruft in the form of whacky APIs and elisp functions, the design of Emacs is stunningly effective. The way that minor modes and keymaps are composed to customize the interaction mode for each individual buffer is clever and beautiful, to name just one thing out of many. And, as janky as elisp is, it's one of the few extension languages that's actually good at its job, and the Emacs elisp API allows you complete freedom over virtually every aspect of the editor. Unironically, Emacs is not a text editor - it's a toolkit for creating text-oriented applications.

Forth, Lisp (Scheme, in particular - I love CL but it's the C++ of Lisps), and Lua - three languages that take a small set of elegant primitives and synthesize them to give you incredible power.

Remember the Milk is a task-tracking SaaS that is one of the few pieces of software that I actually like, which is especially impressive given that it's proprietary. Cheap, fast, effective, and with a UI design that continually impresses me with its mix of intuitiveness and ergonomics.

Turbo Vision/Turbo Pascal for MS-DOS. Borland put together one of the best instances of an object oriented library that just worked. The follow up with Delphi for Windows was the most productive environment I have ever experienced, until I was priced out of it in their pivot to "Enterprise" customers.

Nothing since is anywhere near as productive. Lazarus is ok, but the documentation is horrible, (almost non-existent, only doc-strings in many cases) which makes the system far less useful.

SQLite. It's a damn fine piece of software for small applications.

Syncthing, by a mile.

As someone who very much enjoys tinkering with Linux and such, but also likes trying to onboard other people who aren't as techy, Syncthing is such a killer example. It's almost depressing because I want other free and open source stuff to be this good, though I know the economics (and proprietary interference, perhaps?) make that tough.

Redis. The interface is quickly obvious using telnet (which makes all clients pretty obvious). The documentation is both succinct and complete. All operations are listed with their big-O notation.

I'm going to say vim, and I expect to get yelled at by folk who don't use vim, but here's why I call it elegant software:

Vim's entire command model is based on the simple composition of motion and action.

Until you understand this you will never 'get' vim. You may be able to use it, even efficiently, but you will never understand how these two simple concepts when fully understood are a force-multiplier.

Motion indicates a range, of characters or lines, there are motion keys that will get you: to EOL, to EOF, to next matching char, to braces, to function / class blocks, to predefined marks.

An action is something that applies to that range, these can be anything from auto-formatting, changing case, calling out to another process, anything you can imagine.

When you understand this suddenly g=GG, ct(, y$ become: reformat document, cut to next paren and copy till EOL respectively. Does that sound horribly esoteric? that's only because you don't yet understand vim motion composition.

I'm happy to argue that if anyone fully understands this concept they cannot help but agree that vim is at it's heart seriously elegantly designed software.

Fossil SCM (https://fossil-scm.org/home/doc/trunk/www/index.wiki)

It's almost like Git + Gitea, all in a single application. Code + tickets + wiki + notes all version controlled and capable of hosting the server itself. Also, the repo is just a SQLite database, so backup is easy.

Rollercoaster Tycoon!

The game is beautiful, performant, and almost entirely hand-written assembly by one guy.

Plus, the parks themselves can look very elegant (kind of like factorio factories).

https://www.pcgamesn.com/rollercoaster-tycoon/code-chris-saw...

Git is the first example that comes to my mind.

I'm aware that the concept can be difficult to grasp and that the cli commands seem weird at first.

Once it clicks however, it's an absolutely fantastic tool. I'm still often amazed by what is possible with selective resets, diffs, greps, and most impressively interactive rebases. It makes a lot of otherwise difficult tasks much easier, and more elegant.

Git is IMO one of the most important pieces of software made in the last couple of decades and should be celebrated more for it.

Not a specific piece of software, but a characteristic of a limited percentage of anonymous internal systems--one of the most beautiful things to witness in the realm of design is a system undergoing catastrophic stress when the designers anticipated and planned for such events, and in usually a very short period of time you see the results of extensive planning spool out, design features hidden from view and unappreciated until this moment, kick in and recover/compensate in ways that feel almost magical.

For obvious reasons it is much more common to see this level of design in physical, life-critical systems like aerospace or automotive technology, but you do see it sometimes in software. Well designed services that under heavy load, various kinds of infrastructure failure, attack, or other kinds of scenarios well outside the bounds of normal expected operations intelligently compensate while signaling alerts with precise, useful information, and attempt whatever kind of recovery is possible.

This is hard to anticipate and often thankless to build in advance. It's always a stressful time when this behavior is visible, but it gives me a feeling of admiration for the perhaps long gone employees who built it.

Peter Norvig's 27 line spell checker

https://norvig.com/spell-correct.html

Signal - The elegance here is the "Privacy-first Design". Every feature and code for Signal messenger is designed on collecting as little (or no) data as possible and it is an essential tool for folks like me who are tired of having tracking and ads nonsense in their most-used apps.

Blender.

It's architecture, the window manager/system, the UI, how it is built by and for the users, how the API is integrated and how fast it is compared to other software.

The things app https://culturedcode.com/things/ , even though it's just an elegant TODO app something drove me to buy the iPhone and Mac versions.

Some time ago I spent a good amount of time looking for a development stack that allowed me to just build stuff. I ended up trying and deciding on Laravel Jetstream with InertiaJS https://jetstream.laravel.com/2.x/stacks/inertia.html. Laravel was easy enough already to just pick and do things, now this solves the backend+frontend projects for me by allowing me to just put vuejs components on top of my laravel app and jetbrains already comes with Auth stuff setup solved.

I'd say Linux Mint. It combines everything that's good about Ubuntu while removing things like snap. Also the design is so much better but I feel that's a personal choice. But everything in linux just works so well now.

I run 4 monitors on 2560 resolution on two separate amd cards and everything runs flawlessly. I have all the software for free and most OSS is just as good if not better for my work (except games and Photoshop but photopea is a good alternative for that, and it can be easily my second nomination for this thread).

I know linux has evolved a lot and it's the effort of millions of volunteers which has made Linux what it is today, but for me personally Linux Mint really combines all the great things about linux into an amazingly elegant software.

The Tokio async stack for Rust (https://tokio.rs).

They did a really nice job of building thin layers up the stack from byte buffers (bytes), to async-friendly logging (tracing), basic IO (mio), async runtime (tokio), generic request/response services (tower), HTTP (hyper), and a web framework (axum).

Each of the layers are useful independent of the other layers above, and every one is has a thoughtfully designed, pragmatic interface.

Graphviz.

Non-trivial graphs will make it produce hard-to-read output, and you can try fiddling with it forever to get better output. But it's still the first thing I reach for when I have to make a graph.

Regarding code elegance, OpenBSD[0] surely pride themselves in their code correctness and how they make it clean and understandable.

Another example might be my favorite text editor, vis[1].

[0] https://www.openbsd.org/ [1] https://github.com/martanne/vis

TeXmacs (www.texmacs.org), which is a finely crafted document preparation system realizing at the same time both the structured and the WYSIWYG paradigms. It is vastly superior to all other document preparation systems. In particular it is superior to both TeX (in all its variants) and to Word, under all respects: conceptually, in the power that it affords in manipulating documents, in the ease with which it makes it possible to write, concentrating only on the content and yet having one's document in front of one's eyes.

Turbo Pascal 3 on an IBM 5150. Pick any font color as long as it's green. Editor does automatic indentation and understands arrow keys. Compiler is built in and does one damned job, making EXEs. Runs from a floppy disk and you install it with COPY if you're fancy enough to have a hard drive. The future is wide open.

https://lichess.org

Standard Notes.

Simple. Free. Open Source. E2E encryption. Basically, No frills.

Their idea is to make software not with most features but the one that stays until the next century.

They have a great blog on this philosophy. https://standardnotes.com/longevity

I guess my definition of elegant would be software that has fantastic UX and just works and works so well it boggles my mind how well it works. I'd also extended that to include a foundational core that all other parts can be built off of. In that case, I'd go with vim. I'm not even a huge Vim guy (use it for notes and remote stuff, but not my primary editor), but the concepts are simple and oh so powerful. It's just building blocks on top of text editing.

Pipes in Unix as a concept are also a great abstraction. A bit dated, but still every powerful today.

Files in Unix as well. Some people have gripes which are fair, but the idea that a device, a file, and a socket are all accessed via the same API is fantastic. Of course there are issues, but it's generally worked really well for me.

I'm limiting my choices to open source with good explanatory write-ups or presentations.

Graphite for "simple" time series storage:

https://www.aosabook.org/en/graphite.html

HLL datatype (PFCOUNT, PFADD, PFMERGE) in Redis for counting unique items in a set:

http://antirez.com/news/75

Data structures and algorithms that make Lucene & Elasticsearch fast (video):

https://youtu.be/eQ-rXP-D80U

FFMPEG is an excellent piece of software. I used it last weekend to build an automatic video editor / titler and it only took about 10 hours to make it work. I was going to use moviepy but the rendering time was extreme and the memory consumption was horrible. My 300 line python script with imagemagick and FFMPEG produced a 30 minute long video in under 5 minutes.

Most recently Tailscale, I enabled it on NixOS and minutes later had a secure VPN set up.

MicroKanren: logic programming in roughly 30 loc in any language with first-class functions.

Can’t find original pub; here’s someone’s host of the original paper though: http://webyrd.net/scheme-2013/papers/HemannMuKanren2013.pdf

pandoc comes to mind, one of those pieces of software that “just works.” I’m not a Haskell guy but pandoc makes me wonder sometimes.

Visual Basic (cue the hecklers). Yes the language is awful. But the tool was great. I wish Microsoft (or somebody) would release a new version for full-stack apps with a drag-and-drop UI with js event handlers, easy backend framework, and a one-button “deploy to cloud” button for testing. Then a “publish” button that sets up your CI pipeline for production deployments. I feel like we’ve raised the white flag in terms of what software development should look like in 2022. Writing yaml feels like banging rocks together compared to possible alternatives.

Ecto the database driver for Phoenix is probably the most amazing piece of software I've used. Elegant dx, performant and just enough of an abstraction on SQL.

[1]: https://github.com/elixir-ecto/ecto

Sublime Text introduced multiple cursors to the world. A single incredibly versatile and elegant feature. That feature has empowered my ability to use other pieces of software faster, and programming languages I was unfamiliar with... Better.

I've used it to:

- batch edit columns copied from excel files.

- wget/rename/run cli commands on dozens of inputs without having to worry about how for loops are written in bash/bat/powershell by just typing commands on a hundred lines and concatenating them with &&

- extract data from various text files without writing parsers or even thinking about regexes

This is one keyboard shortcut, with one of the smoothest learning curves ever. Pure elegance.

Nim. It's just so quick and easy to write high performance code. That's why I'm writing a web framework for it, soon to be released: https://github.com/jfilby/nexus

I don't see Airtable here yet. That team managed to make relational databases user-friendly to a consumer market without compromising the core features a power user might expect. Hats off to them!

The original MapReduce implementation by Jeff Dean and friends is probably up there for me. Couple of hundred lines of code doing bunch of task distribution on a very large scale is just very impressive.

Of course the current/latest version of it has took a life of its own in size and complexity (but of course with performance and reliability too) but the initial version still shines through!

After 50 years it doesn't seem like it, but C has managed to survive this long because it's a solid all-round player from the bare metal to web servers. It's simple enough that you could probably implement a fairly capable C compiler in assembler.

Monument Valley and Monument Valley 2[0].

They're games, and relatively short/easy, but it's beautiful and elegant.

[0] https://www.monumentvalleygame.com/mv2

Keyboard Maestro. It’s a tool for automating common tasks on a Mac. A real programming language is certainly more elegant for writing programs. But what I find elegant about Keyboard Maestro is that it lets me add programming logic to any application on my Mac, quick and dirty.

Unpopular opinion but Microsoft Excel. It's a powerhouse of features.

Unison, the rsync-like tool, has an awesome interface. ( https://www.cis.upenn.edu/~bcpierce/unison/ )

Prolog. There's a reason it's been king of the Logical Paradigm for decades.

Oberon OS.

Turing Drawings. ( https://maximecb.github.io/Turing-Drawings/ )

procmail ( https://en.wikipedia.org/wiki/Procmail ) one of the most beautiful (yet hideous) programs I have ever read.

Are unix pipes a software? If so, then that.

Norton Commander - https://en.wikipedia.org/wiki/Norton_Commander. Not sure how elegant on the inside, but it comes from the era when software development was not so fast paced. And the fact that it inspired so many spin-offs (just to mention few that I personally used: Volkov Commander, Midnight Commander, FAR Manager, and my favourite - DOS Navigator (it had spreadsheet!)).

Linear is nice. https://linear.app

JonesFORTH

Although one might argue it to be a case of really elegant documentation and literate programming.

mIRC feels elegant by today's standards.

A full-featured IRC client for Windows that includes an entire scripting language and yet it consumes less RAM than calc.exe.

Stockfish -- https://github.com/official-stockfish/Stockfish

Some of the best C++ code written. Extremely clear and concise. Chess-AI is a bit complicated but the source-code + comments seems to inform the programmer where all the problems are.

As other mentioned algorithms I found that ideas behind Bloom filter (https://en.wikipedia.org/wiki/Bloom_filter) and Geohash (not to be confused with geohashing or geo caching, see https://en.wikipedia.org/wiki/Geohash and Z-order curves) are extremely elegant and inspiring.

Vary random but these are stuff which impressed me on first try and never let me down:

Kitty, the terminal emulator by Kovid Goyal

wouter, a minimal JS routing library

espanso, a text expansion program

KDE Connect

Tailscale

The last 2 together

curl

Automated trains / subways. They are reliable enough for millions of people to trust them with their life, every day. That's an incredible achievement.

If you're ever in Paris, get a front-row seat on subway line 14 and feel the magic.

Notational Velocity

Very simple, instant search, and having the same UI for searching and creating notes is genius - way fewer duplicated notes, for one thing.

The Elm architecture. I've only used it in F# with Fable but it's made UI programming fun again. It's robust and simple.

I've been pleased by NATS (https://nats.io/). I like how it builds its functionality on layers of abstractions, from the most basic (pub/sub), to request/response on top of that, to key/value and persistent streams on top of that. The CLI is simple to use and you can learn it in an afternoon, but it's robust enough to deploy.

https://github.com/enkimute/ganja.js/

Geometric algebra for any R{p,q,r} dimensional space. Has it own custom JS to JS transpiler so the literal number "1e10" becomes a bivector. The code is just around a thousand lines while it lets you do amazing things like this right in the browser:

https://enkimute.github.io/ganja.js/examples/coffeeshop.html...

Open Hardware Monitor (OHM)

It's written in C# and the design seemed clean and approachable (at least a few years back when I tailored it a bit for my own use).

https://openhardwaremonitor.org/downloads/

https://github.com/openhardwaremonitor

Spotlight. Everything about it is really well-thought out. I use it dozens of times every day to convert units or hold strings or check the weather.

I think an honorable mention should go to PyGame.

I used this to show my kids how computer games work. I started out by showing them Unreal Engine 4 so they understand the modern tool chain, but that still leaves the mystery of how the game is represented inside the computer. Within minutes you can have some code drawing things, real graphics, on the screen. I cannot adequately describe how easy it is.

The experiment I did with them (young kids) was define some variables, draw a counter on the screen, start a loop, and then increment the counter. After they saw how that was represented to the computer it was easy to get them to imagine a character with all of his stats assigned at the beginning and then updated on every iteration of the loop as events take place. But with kids you've gotta move fast or they lose interest. PyGame makes creating games so fast you can literally pick it up and start teaching it to kids without knowing it yourself. It's that good.

Stardew Valley! I always marveled at how it was a one man team, and everything from the graphics to the game systems seemed to work well. I haven't seen the code base or anything, so I am not sure if this is 'elegant', but my assumption is that for one person to put out that kind of work, some things have to be going right in the design.

Python Trio[0] (an alternative async stack to the builtin asyncio).

It allowed me to implement a mini OTP framework in Python[1].

[0] - https://trio.readthedocs.io/

[1] - https://linkdd.github.io/triotp/

Scheme.

> Abstract: We show that it is Scheme, of the Lisp family, the language that deterministically emerges when one opts for elegance.

https://chaitinschool.org/blog/the-most-elegant-of-arrays/

emacs, both for the elegance of its elisp-machine design and for how good its self-documentation is.

Lua

numpy started a science renaissance. fantastic library for what it does.

The original QSpy protocol, which then became the GameSpy protocol, and later still made way for Valve's Master Server protocol.

I'm not sure what other protocols exist today for tracking a list of servers, providing information on them, and are as up to date as the frequency of the heartbeats from those servers, but I suspect there are similar protocols out there, and I'm just not familiar with them.

Unfortunately despite how elegant the QSpy protocol is, most modern video games no longer provide server browsers as first-class features, eschewing them in favor of matchmaking services or publisher provided dedicated servers.

NixOS (although yes it could be even more elegant than it is)

Python

The language design of python made almost everyone learn programming.

SolidWorks

Altium

Comsol

Proprietary yes, but I’ve used all three over the last few years and found them each to be very streamlined, productive, and elegant after a fashion.

WireGuard

Diagram!, by Lighthouse Design, for NEXTSTEP. A drawing tool that featured "smart links." I believe it pre-dated Visio. Later cloned as OmniGraffle by OmniGroup.

Elegance for me means a program that's lightning fast, efficient to use, and has a minimal learning curve. The first things that come to mind:

OurGroceries, a lovely little free app to share grocery lists with your family FooBar2000, an early windows-based media player uTorrent (or at least the very early versions, before it became bloatware) Snapchat (again, the early versions when it was 5x quicker than any other mobile photo sharing platform)

BEAM (Erlang VM)

Scrivener.

It's very focused on the task of writing - novels, short stories, screenplays. It pares away the parts of e.g. a word processor that are distracting (layout and the like), adds the functions of a database for tracking characters, locations, research and so on.

The underlying implementation is also storing as plain files in directories, so you can be comfortable that you'll be able to retrieve your writing if Scrivener no longer exists.

Sequel [1], the Ruby ORM. It's rock-solid, provides similar abstractions to Active Record but feels much better thought out, and it has great docs.

Also, at any point in time, it's likely to have zero open issues and zero open pull requests, which is pretty impressive for a project of its size.

[1]: https://github.com/jeremyevans/sequel

We put a lot of effort and consideration into the architecture of Unikraft[0][1], its elegance towards modularity and abstraction is the reason why I joined the team to help develop it. :)

[0]: https://unikraft.org/

[1]: https://github.com/unikraft/unikraft

Circus Ponies Notebook (On OpenStep, then OS X), made my jaw literally hit the floor when I first saw it. I didn't just think all software had something to learn here, I thought this was the only software anyone would ever need.

To be fair, my job lend itself toward this at the time, the WWW was nowhere near what it was a few years later, and everything-tied-to-everything was miles away. But this blew my mind.

PostgreSQL

- TCL/TK

- CWM

- Music On Console

- Sfeed+sfeed_curses+xargs+wget+MOC

- Entr

- Mit-Scheme + Edwin + SICP. It doubles as an IMAP client. Use Stunnel for TLS.

- UDFClient

- NNCP

- S-Nail. It can be easier than Mutt.

Things! The todo list app. It's the most elegant app I've ever used. feels like it just works, and I can rely on it 100%.

Elegant construction and elegant use can be disjoint. For construction, Beautiful Code is a good read on a bunch of real specimens.

https://www.oreilly.com/library/view/beautiful-code/97805965...

Everything, a Windows application which finds/searches files instantly. If MS Windows would include this as standard search function the worldwide GDP would probably go up by like .1% from the productivity gain. https://www.voidtools.com/

Optimal ordered problem solver: http://people.idsia.ch/~juergen/oopscode.c

(From http://people.idsia.ch/~juergen/oops.html)

For Docker stacks: Funkwhale [1]

Their Setup for the Docker stack [2] is not only well documented, but also suitable as a blueprint for any persistent software setup with Docker. They also have a mentality for documentation as a firct class member, which is really important for OSS and self-hosting. You'd have to look hard to find any outdated piece of information or lazy written part in the docs. Lastly, the interface is just beautiful, simple and elegant. I finally enjoy listening to my music library again.

[1]: https://funkwhale.audio/ [2]: https://docs.funkwhale.audio/installation/index.html#availab...

Sublime Text

I'm not sure if this has come before but for me it'd be ffmpeg. The things it can do!

4.3BSD Unix. Arguably, the first modern operating system.

https://en.wikipedia.org/wiki/History_of_the_Berkeley_Softwa...

ZFS. It made filesystems and Software RAID elegant and accessible with an elegant interface and a pleasure to work with. It offers all the features that one would want in a file system without many shiny bloat.

Scrubs

Distributed parity

Hot spares

Encryption

Snapshots

Compression

Quotas

All in an intuitive way that led to an almost cult like following in the Unix/Linux admin world.

https://vertx.io and https://lmax-exchange.github.io/disruptor/

Apostrophe (https://gitlab.gnome.org/World/apostrophe). ABSOLUTELY GORGEOUS design. Smooth and clean. No words to describe it.

A very short example: The PNPOLY algorithm https://wrf.ecse.rpi.edu/Research/Short_Notes/pnpoly.html

LISP 1.5

Microware OS-9. A Unix-like (..sort of) operating system that supported multitasking, multiuser operation on an 8 bit CPU with 64kb or less of memory back in 1979.. two years before IBM bought a CPM clone and called it DOS.

Obsidian.md - the markdown note taking app. I find it intuitive and powerful.

The Fork Git client is pretty much perfect (and native) on Mac and Windows

Solvespace (CAD)

https://solvespace.com/index.pl

A single executable of about 6MB with pretty significant capability.

The source code is pretty clean as well.

[1] https://en.wikipedia.org/wiki/Open_Firmware

[2] https://en.wikipedia.org/wiki/Architecture_Neutral_Distribut...

[3] https://en.wikipedia.org/wiki/TRON_project

Software ?= software application

If yes, then I’ll offer an oldie but a goodie: Adobe Photoshop.

Many of its tools are intuitive. As a photo artist you don’t want the application getting in your way. It’s easy to learn how PS organizes multi-color/layer/channel images. You can do a lot with a little bit of knowledge of the application, so you can do the simplest things easily and quickly. With more application skill you can produce the highest quality images necessary for _any_ static image project.

I love utilities that quietly work, and just accept whatever workflow I throw at them.

OwnTracks is an app that logs your position and sends it somewhere else. It has been running on my phone for like 2 years without issues, and talks to a server I wrote myself.

FolderSync syncs folders on my phone to remote storage. It's super flexible and generally just works. The conditions for syncing are highly configurable. I lament the lack of a similar utility on Mac - basically an rsync+cron UI.

I'm on Windows and hated the File-Explorer for years: it always resets the view (even if you told it to use your standard view for all folders) and has terrible defaults.

I tried many alternatives, then finally found XYplorer. It is so easy to use, well structured, but when needed it is also a power house full of soo many tools you otherwise need another app for. Really loving it and many kudos to the only(?) developer from Germany who constantly improves it.

Bear Blog is simple to use, understand, with no frills or client-side JS. https://bearblog.dev

AWK

Match this, do that.

Frigate NVR: https://frigate.video/

Incredibly easy to host open source network video recorder with object tracking and hardware acceleration support. You have to install hardware and know what you're doing to hook things up, but bespoke systems that do these things cost tens of thousands for hardware/licensing alone and don't do them half as well.

Elegance is usually an unassertive quality. It's harder to say what software is elegant than it is to say what isn't elegant. To me it usually means that something is done correctly for you, things are presented clearly, and annoying chores are removed. Consistency and a lack of surprises.

The first thing that comes to mind as elegant compared to the alternatives is k9s for managing/monitoring kubernetes.

Alfred (Mac launcher)

This is an obscure one, but Mike Innes "[automatic] differentiation for hackers" tutorial. It's a code tutorial, not software, if that counts. Both the way it's constructed and the functionality of Julia that gets shown off here.

https://github.com/MikeInnes/diff-zoo

Thinkorswim by TDAmeritrade. No one else has figured out how to lay out options (greeks, premium), charts etc. in such an intuitive manner.

MindNode is a beautiful way to lay out your thoughts, and the graphs can be copied as bulleted lists. Alfred is an application launcher that also lets me enter shortcuts to quickly launch pages like my calendar and each of my team members' open PRs. I use it dozens, if not hundreds, of times a day. With the premium version, you also get a great clipboard manager.

GHC, the Haskell compiler.

Rustc.

Pov-RAY (for creative interpretations of "elegant").

Diff and patch.

The original Starcraft and BroodWar.

Battle for Wesnoth.

Bittorrent.

Probably one not many people have used or heard of: CoCreate Solid Designer.

NetBSD and OpenWRT. These platforms build across archs relatively easily and their configuration interfaces are pretty transparent.

- NXT-G, the coolest (simple) visual programming language

- Propellerheads Reason, a sweet DAW

- emacs, a text editor so elegant it’s a real OS

- Procreate, the nicest iOS drawing app

blender (the finished product, can't comment on the code itself).

I can't speak to the quality of the code base (I don't know go), but as a user caddyserver is pretty great.

Adobe Photoshop around v3/4/5 (newer versions may be as good or better, but I haven’t used them)

Microsoft SQL Server 7 or later

NextStep

BitTorrent (more the protocol, but could also apply to any good implementation)

JetBrains software (pretty much any of it)

Think Pascal

ZFS

OS/firmware in Nokia “slab” phones from the late 90’s

StarCraft II, original Tetris, original SimCity (since all the cool kids are suggesting games)

Ahrefs https://ahrefs.com/ is great seo tool that I use to analyze my website's (https://aemorph.com) link profile, ranking, and SEO health.

Vega-Lite and Altair

https://vega.github.io/vega-lite/ https://altair-viz.github.io/

https://tetr.io/

even on an ancient laptop, it runs smoothly. I had no idea a javascript game could look/play this good. I've spent 100 hours on it since I first saw it posted here on HN

The Visio that came on the sampler floppy. It was small and did an amazing job.

PFE back in the day. Simple macros and templates that made life much easier in a small package. Some editors today don't even bother with macros or have all of PFE's options.

Nobody seems to have mentioned qemu. Right, it's proably more genius than elegant.

I have created my blog almost a decade ago, https://reiblast.blogspot.com/ I'd like to know any new blogging site that is better than google?

IntelliJ and Goland. I mean both Eclipse and Visual Studio used to be good tools, but they lost it, however IntelliJ remains to be a good tool, throughout the years. Also Goland is much better than Visual Studio Code, imho.

Creating a GUI Interface in Visual Basic to See If I Can Track An IP Address

https://www.youtube.com/watch?v=hkDD03yeLnU

Projects developed under a BDFL: blender (ton) vim (bram) and python (guido)

LLVM is pure joy to use in every regard. A priceless marvel of open source.

Softimage, this is was the first 3D software that I really learned and the UI/UX was way ahead of its time.

Macromedia Director, it was amazing how quickly you could create an interactive standalone app or CD-ROM.

`pass`, no cap.

passwordstore.org

Spotify (brilliant!), unix, Google's Flume, DynamoDB, EC2, the Lithium ereader app on android (simplicity is good!), Wikipedia, Google Search (or perhaps Old Google Search), emacs, vscode

LINQPad by Joseph Albahari

Scrivener: https://www.literatureandlatte.com/scrivener/overview

First coming to mind, HackerNews. No images, no ads, no complex settings UI, no complex points/karma system. Just text and links, it does what it's built for and does it well.

Scanwatch – Fast and simple file watcher for Node

https://www.npmjs.com/package/scanwatch

Aegis/Domain OS. I would love to work again with such an OS.

RabbitMQ. It just works.

I've always liked how TaskPaper was entirely built around plain text files.

https://www.taskpaper.com

https://every-layout.dev - not just the ideas it conveys, but the site per se too.

Lotus Improv.

One of the most beautiful spreadsheet programs ever designed.

IEFBR14 https://en.wikipedia.org/wiki/IEFBR14

Websites: HN, sourcehut. Tech: Prisma. App: Postico.

Since no one seems to have mentioned it yet: D3.js

Scikit-Learn's api is masterfully consistent. We've taken to using it as a source of inspiration for our own code.

Total commander. By far the most ergonomic UI for working with multiple directories on Windows except of a terminal.

TiddlerWiki.

It's not everyone's cup of tea, but given the limitations it has decided to work within, it really is a wonder.

A couple of my favorite programmable products from the MSDOS years:

Telix

QEdit

The newish email service Hey. For me it’s been really successful in its attempt to be useful and a bit whimsical.

Things, a todo system for macOS and iOS.

Git, grep, sed, awk; many Unix utils

This is interesting question, several times I complemented Telegram in front of friends

Hazel. Automation at every level and an easy intro into scripting for non-programmers.

IMHO Lotus Improv/OpenStep Quantrix is the epitome of elegant software.

A lot of nice examples in Donald Knuth's The Art of Computer Programming.

vim

VS Code

workflowy. i use dynalist these days as my main outliner / note taker since it has a lot more features, but workflowy still just has something more elegant and minimal going on with its UI

Vim

Adobe Indesign

Monodraw

GNUcash

Django

Beeminder

The Apache HTTP Server and the GNU Scientific Library come to mind.

Boop.app for mac, also both Sublime Text and Sublime Merge.

ZIO, a functional effect system (+ a lot more) for Scala.

My code is always super elegant compare to the rest

I'm surprised nobody has mentioned windows 11

non-boost asio: https://think-async.com/Asio

You might like the book "beautiful code"

imagemagick,ffmpeg

Sidefx Houdini

SpiderMonkey, while it isn’t the best performing, its code is pretty straightforward. It also seems to be embeddable on its own, unlike V8.

Taskwarrior.

kdb+. It may be a little over-marketing, but it's really elegant. voodoopad.

Mathematica

tmux

bbedit

Does exactly what it promises

gnuplot

Being able to just plot sin(x) blew my mind.

More seriously: cholmod

Ableton Live

fzf, dmenu, dunst, curl, jq, pup

xcode

haha just kidding!

meld

xmonad

My favorite example of elegant software is the way Spotify organizes playlists and allows for playlist sharing between users. The playlists are very easy to search, browse, and make. They are also easy to share with friends, and you can find an endless number of playlists curated by other users on almost any topic you can imagine!

The three of life is a fantastic design and use of openstreetmap software https://lifemap.univ-lyon1.fr/explore.html

Always impressed with Palantir's software.