from Hacker News

Ask HN: What are your favorite examples of elegant software?

by joshbochu on 5/2/22, 2:47 AM with 408 comments

design or otherwise

  • by cedws on 5/2/22, 6:00 PM

    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.

  • by throw10920 on 5/2/22, 8:27 PM

    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.

  • by mikewarot on 5/2/22, 5:29 AM

    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.

  • by m-p-3 on 5/2/22, 11:48 AM

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

  • by jrm4 on 5/2/22, 6:27 PM

    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.

  • by bajsejohannes on 5/2/22, 9:14 AM

    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.

  • by tjstebbing on 5/3/22, 5:40 AM

    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.

  • by pyjarrett on 5/2/22, 6:22 PM

    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.

  • by Centigonal on 5/2/22, 11:44 PM

    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...

  • by jeppester on 5/2/22, 9:32 PM

    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.

  • by hatchnyc on 5/3/22, 1:18 AM

    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.

  • by biorach on 5/2/22, 8:52 PM

    Peter Norvig's 27 line spell checker

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

  • by gordon_freeman on 5/2/22, 7:26 PM

    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.

  • by blenderdt on 5/2/22, 8:56 PM

    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.

  • by iwebdevfromhome on 5/2/22, 8:00 PM

    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.

  • by superasn on 5/2/22, 7:17 PM

    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.

  • by emschwartz on 5/2/22, 6:45 PM

    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.

  • by Stampo00 on 5/2/22, 8:35 PM

    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.

  • by Gualdrapo on 5/2/22, 6:32 PM

    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

  • by GiovanniP on 5/2/22, 7:42 PM

    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.

  • by 13of40 on 5/3/22, 12:33 AM

    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.

  • by yewenjie on 5/2/22, 6:20 PM

  • by whoibrar on 5/2/22, 6:47 PM

    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

  • by jjice on 5/2/22, 8:28 PM

    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.

  • by pixelmonkey on 5/2/22, 5:47 PM

    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

  • by ohiovr on 5/2/22, 8:55 PM

    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.

  • by madjam002 on 5/2/22, 5:55 PM

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

  • by ashton314 on 5/3/22, 12:01 AM

    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

  • by _virtu on 5/2/22, 8:08 PM

    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

  • by _vdpp on 5/3/22, 2:25 AM

    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.

  • by jasfi on 5/2/22, 7:23 AM

    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

  • by laserbeam on 5/3/22, 4:04 AM

    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.

  • by jdauriemma on 5/2/22, 6:48 PM

    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!

  • by kettunen on 5/2/22, 7:56 PM

    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!

  • by phoehne on 5/2/22, 5:51 PM

    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.

  • by Mister_Snuggles on 5/2/22, 8:48 PM

    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

  • by leobg on 5/2/22, 4:10 PM

    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.

  • by sidcool on 5/2/22, 5:24 AM

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

  • by carapace on 5/3/22, 12:50 AM

    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.

  • by dusted on 5/2/22, 8:09 AM

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

  • by archielc on 5/2/22, 8:30 PM

    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!)).

  • by nikivi on 5/2/22, 10:38 AM

    Linear is nice. https://linear.app

  • by j-pb on 5/2/22, 5:56 AM

    JonesFORTH

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

  • by Sohcahtoa82 on 5/2/22, 3:59 PM

    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.

  • by dragontamer on 5/2/22, 7:11 PM

    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.

  • by kretaceous on 5/2/22, 7:49 PM

    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

  • by centur on 5/3/22, 2:51 AM

    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.

  • by oxley on 5/3/22, 3:43 AM

    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.

  • by lukasb on 5/2/22, 8:39 PM

    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.

  • by xupybd on 5/2/22, 9:47 AM

    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.

  • by paulgb on 5/2/22, 8:04 PM

    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.

  • by wrnr on 5/2/22, 8:15 PM

    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...

  • by rkagerer on 5/2/22, 8:41 PM

    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

  • by PascLeRasc on 5/2/22, 8:51 PM

    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.

  • by mym1990 on 5/2/22, 9:46 PM

    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.

  • by zelon88 on 5/3/22, 4:41 AM

    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.

  • by linkdd on 5/2/22, 11:18 PM

    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/

  • by sirodoht on 5/3/22, 1:59 AM

    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/

  • by AlanYx on 5/2/22, 5:47 PM

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

  • by spacechild1 on 5/2/22, 9:16 AM

    Lua

  • by morelandjs on 5/2/22, 1:48 PM

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

  • by andrewmcwatters on 5/2/22, 7:15 PM

    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.

  • by spindle on 5/2/22, 4:05 AM

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

  • by orsenthil on 5/3/22, 1:42 AM

    Python

    The language design of python made almost everyone learn programming.

  • by tigerlily on 5/2/22, 6:22 PM

    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.

  • by heavyset_go on 5/2/22, 6:24 PM

    WireGuard

  • by throwawayboise on 5/2/22, 6:50 PM

    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.

  • by alexose on 5/3/22, 3:45 AM

    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)

  • by type0 on 5/2/22, 1:27 PM

    BEAM (Erlang VM)

  • by rodgerd on 5/3/22, 1:15 AM

    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.

  • by uhoh-itsmaciek on 5/3/22, 12:23 AM

    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

  • by nderjung on 5/2/22, 6:32 PM

    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

  • by smm11 on 5/2/22, 10:12 PM

    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.

  • by spacemanmatt on 5/2/22, 9:16 AM

    PostgreSQL

  • by anthk on 5/2/22, 7:59 PM

    - 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.

  • by djmashko2 on 5/2/22, 7:14 PM

    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%.

  • by ibejoeb on 5/2/22, 6:21 PM

    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...

  • by ju-st on 5/3/22, 11:57 AM

    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/

  • by aasasd on 5/3/22, 5:11 AM

  • by Helmut10001 on 5/3/22, 3:36 AM

    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...

  • by saikatsg on 5/2/22, 6:52 PM

    Sublime Text

  • by pddpro on 5/2/22, 10:53 PM

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

  • by ibiza on 5/2/22, 7:43 PM

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

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

  • by reacharavindh on 5/3/22, 11:39 AM

    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.

  • by throwaway_dcnt on 5/2/22, 9:27 PM

  • by memorable on 5/3/22, 12:06 AM

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

  • by crispisulcans on 5/2/22, 9:52 PM

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

  • by eimrine on 5/2/22, 3:23 AM

    LISP 1.5

  • by spogbiper on 5/2/22, 7:44 PM

    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.

  • by libraryatnight on 5/2/22, 11:07 PM

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

  • by hadrien01 on 5/2/22, 6:40 PM

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

  • by phkahler on 5/2/22, 10:00 PM

    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.

  • by LargoLasskhyfv on 5/3/22, 6:23 AM

  • by xtiansimon on 5/3/22, 11:53 AM

    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.

  • by nicbou on 5/2/22, 7:13 AM

    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.

  • by movetheworld on 5/3/22, 5:30 AM

    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.

  • by HermanMartinus on 5/2/22, 10:57 AM

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

  • by pphysch on 5/2/22, 5:51 PM

    AWK

    Match this, do that.

  • by Tao332 on 5/3/22, 3:28 AM

    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.

  • by leobg on 5/2/22, 4:12 PM

    Alfred (Mac launcher)

  • by version_five on 5/3/22, 12:55 AM

    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

  • by nabaraz on 5/2/22, 7:14 PM

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

  • by cnees on 5/2/22, 9:19 PM

    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.

  • by elihu on 5/3/22, 12:01 AM

    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.

  • by caraboga on 5/2/22, 9:14 PM

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

  • by dhash on 5/2/22, 11:14 AM

    - 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

  • by ur-whale on 5/2/22, 7:40 PM

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

  • by drunner on 5/2/22, 6:08 PM

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

  • by commonalitydev on 5/4/22, 9:10 AM

    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)

  • by f0000 on 5/2/22, 9:58 PM

  • by nope96 on 5/2/22, 10:26 PM

    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

  • by protomyth on 5/2/22, 9:27 PM

    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.

  • by usr1106 on 5/3/22, 5:46 AM

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

  • by MichaelMoser123 on 5/3/22, 4:42 AM

    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.

  • by otikik on 5/2/22, 9:40 PM

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

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

  • by dustractor on 5/2/22, 8:48 PM

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

  • by ubadair on 5/3/22, 3:55 AM

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

  • by RubberMullet on 5/2/22, 8:19 PM

    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.

  • by orhunp_ on 5/2/22, 6:49 PM

    `pass`, no cap.

    passwordstore.org

  • by iroh2727 on 5/3/22, 2:07 AM

    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

  • by weef on 5/3/22, 12:08 AM

    LINQPad by Joseph Albahari

  • by bradwood on 5/2/22, 8:20 PM

  • by xhrpost on 5/3/22, 4:23 AM

    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.

  • by d08ble on 5/2/22, 9:22 PM

    Scanwatch – Fast and simple file watcher for Node

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

  • by hulitu on 5/2/22, 7:38 AM

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

  • by jansc on 5/2/22, 5:58 PM

    RabbitMQ. It just works.

  • by sparker72678 on 5/2/22, 9:43 PM

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

    https://www.taskpaper.com

  • by chrisweekly on 5/2/22, 9:14 PM

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

  • by SeanLuke on 5/3/22, 12:47 AM

    Lotus Improv.

    One of the most beautiful spreadsheet programs ever designed.

  • by blame-troi on 5/3/22, 1:50 AM

  • by modinfo on 5/2/22, 8:02 PM

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

  • by Zecc on 5/3/22, 7:41 AM

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

  • by annowiki on 5/2/22, 7:05 PM

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

  • by rad_gruchalski on 5/3/22, 11:56 PM

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

  • by Stampo00 on 5/2/22, 8:37 PM

    TiddlerWiki.

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

  • by spacemanmatt on 5/2/22, 12:20 PM

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

    Telix

    QEdit

  • by felipemesquita on 5/3/22, 1:22 AM

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

  • by hnarayanan on 5/2/22, 7:43 PM

    Things, a todo system for macOS and iOS.

  • by smokeyfish on 5/2/22, 9:47 PM

    Git, grep, sed, awk; many Unix utils

  • by massprogrammer on 5/2/22, 11:04 PM

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

  • by ents on 5/2/22, 11:16 PM

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

  • by pasttense01 on 5/3/22, 6:42 AM

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

  • by mshaler on 5/4/22, 4:55 PM

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

  • by nathias on 5/2/22, 8:27 PM

    vim

  • by Xenoamorphous on 5/2/22, 8:04 PM

    VS Code

  • by constantinum on 5/2/22, 5:58 PM

    Vim

    Adobe Indesign

    Monodraw

    GNUcash

    Django

    Beeminder

  • by mackrevinack on 5/3/22, 3:46 AM

    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

  • by rwxrwxrwx on 5/2/22, 10:26 PM

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

  • by rubyist5eva on 5/2/22, 8:11 PM

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

  • by hamandcheese on 5/3/22, 4:21 AM

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

  • by macampam on 5/3/22, 4:35 AM

    My code is always super elegant compare to the rest

  • by stillblue on 5/3/22, 4:12 AM

    I'm surprised nobody has mentioned windows 11

  • by bennysomething on 5/2/22, 9:11 PM

    You might like the book "beautiful code"

  • by uberwindung on 5/3/22, 7:52 PM

  • by boban_dj on 5/3/22, 1:52 AM

    imagemagick,ffmpeg

  • by MrScruff on 5/2/22, 9:58 PM

    Sidefx Houdini

  • by pipeline_peak on 5/2/22, 6:41 PM

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

  • by 2143 on 5/2/22, 6:14 PM

    Taskwarrior.

  • by secwang on 5/3/22, 2:19 AM

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

  • by phonon on 5/2/22, 8:35 PM

    Mathematica

  • by 1vuio0pswjnm7 on 5/2/22, 8:22 PM

    tmux

  • by walrus01 on 5/3/22, 4:07 AM

    bbedit

    Does exactly what it promises

  • by enriquto on 5/2/22, 10:00 PM

    gnuplot

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

    More seriously: cholmod

  • by chordmemory on 5/5/22, 1:48 AM

    Ableton Live

  • by ducktective on 5/2/22, 9:35 PM

    fzf, dmenu, dunst, curl, jq, pup

  • by hnxs on 5/2/22, 9:25 PM

    xcode

    haha just kidding!

  • by dvh on 5/2/22, 6:43 PM

    meld

  • by ravish0007 on 5/3/22, 2:36 PM

    xmonad

  • by Parker_Powell on 5/3/22, 6:23 AM

    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!

  • by hatware on 5/2/22, 6:18 PM

    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.

  • by SemanticStrengh on 5/3/22, 12:48 AM

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

  • by pcurve on 5/2/22, 6:19 AM

    Always impressed with Palantir's software.