HackerReposA FIELD GUIDE TO OPEN SOURCE
ProSponsor the shelf♧ 0
← Back to top all-time
tinspin
rupy
Java2015–2025
tinspin / rupy

rupy

HTTP App. Server and JSON DB - Shared Parallel (Atomic) & Distributed

4Distinct people
74Mentions
1Explicit recommenders
149GitHub stars
REPOSITORY AT A GLANCE

What to know before exploring

What it is

HTTP App. Server and JSON DB - Shared Parallel (Atomic) & Distributed

GitHub

Where it is used

No documented product use has been verified yet.

What people are saying

I use ext4 with my distributed async-to-async JSON database: https://github.com/tinspin/rupy/wiki/Storage You can try it here: http://root.rupy.se The actual syncing is done…

bullen used a recommendation phrase. One indexed comment matches. This is a phrase match, not a verdict.

No classified warning is attached to this page. Read the discussions before treating silence as approval.

Also in these discussions

No other repository is repeatedly linked in the same discussions.

This week on Hacker News

Nov 9–Nov 16 UTC · Direct repository links and separately labeled related project stories. Indexed through 11/16/2026, 1:56:48 AM UTC.

No direct repository links were found in the indexed HN discussions over the past seven days. Older discussions are available below.

Mentions over time

HN mentions by year74 dated mentions

Observed mentions: 2015-12-23 11:00:41 UTC to 2025-08-22 10:19:37 UTC.

0510152015-01-01 00:00:00 UTC to 2016-01-01 00:00:00 UTC (exclusive): 1 mentions; 0 submissions, 1 comments20152016-01-01 00:00:00 UTC to 2017-01-01 00:00:00 UTC (exclusive): 4 mentions; 0 submissions, 4 comments2017-01-01 00:00:00 UTC to 2018-01-01 00:00:00 UTC (exclusive): 8 mentions; 0 submissions, 8 comments2018-01-01 00:00:00 UTC to 2019-01-01 00:00:00 UTC (exclusive): 10 mentions; 0 submissions, 10 comments2019-01-01 00:00:00 UTC to 2020-01-01 00:00:00 UTC (exclusive): 6 mentions; 0 submissions, 6 comments2020-01-01 00:00:00 UTC to 2021-01-01 00:00:00 UTC (exclusive): 9 mentions; 0 submissions, 9 comments20202021-01-01 00:00:00 UTC to 2022-01-01 00:00:00 UTC (exclusive): 15 mentions; 0 submissions, 15 comments2022-01-01 00:00:00 UTC to 2023-01-01 00:00:00 UTC (exclusive): 13 mentions; 0 submissions, 13 comments2023-01-01 00:00:00 UTC to 2024-01-01 00:00:00 UTC (exclusive): 6 mentions; 0 submissions, 6 comments2024-01-01 00:00:00 UTC to 2025-01-01 00:00:00 UTC (exclusive): 0 mentions; 0 submissions, 0 comments2025-01-01 00:00:00 UTC to 2026-01-01 00:00:00 UTC (exclusive): 2 mentions; 0 submissions, 2 comments2025

Counts come from the repository’s dated source evidence. Index cutoff: 2026-11-02 08:16:59 UTC.

View mention counts and date ranges
UTC ranges include their start and exclude their end. Select a period to filter the source evidence.
PeriodStart (UTC)End (exclusive, UTC)MentionsSubmissionsComments
20152015-01-01 00:00:00 UTC2016-01-01 00:00:00 UTC101
20162016-01-01 00:00:00 UTC2017-01-01 00:00:00 UTC404
20172017-01-01 00:00:00 UTC2018-01-01 00:00:00 UTC808
20182018-01-01 00:00:00 UTC2019-01-01 00:00:00 UTC10010
20192019-01-01 00:00:00 UTC2020-01-01 00:00:00 UTC606
20202020-01-01 00:00:00 UTC2021-01-01 00:00:00 UTC909
20212021-01-01 00:00:00 UTC2022-01-01 00:00:00 UTC15015
20222022-01-01 00:00:00 UTC2023-01-01 00:00:00 UTC13013
20232023-01-01 00:00:00 UTC2024-01-01 00:00:00 UTC606
20242024-01-01 00:00:00 UTC2025-01-01 00:00:00 UTC000
20252025-01-01 00:00:00 UTC2026-01-01 00:00:00 UTC202

What Hacker News says

15 sources
I made my own HTTP app. server and JSON database on top of that. The server accepts .jars over HTTP with code (and files) so I can hotdeploy while developing on live on the entire cluster in real time. My turnaround is about 1 second. The JSON database allows for schema-less simplicity, and it has all the features you need like indexes, relations, multi crossref and security (and then some, like global realtime distributed while still being performant) in 2000 lines of code. I have zero pain developing the most scalable (and energy efficient) backend in the world, yet very few seem to care or use it: https://github.com/tinspin/rupy It has been proven on a real project with 5 years uptime and 350.000 users: https://store.steampowered.com/app/486310/Meadow/
In Ask HN: Solo-preneurs, how do you DevOps to save time?
I would have written rupy in C with atomic pointers and .so/.dll hot-deploy if I had done it now, but: All concurrent complex datatypes leak memory with C/C++, I don't know why; but if you read the quotes you'll see others try to explain it: https://github.com/tinspin/rupy/wiki The VM is good for more things than concurrency, like no seg. fault crashes, which is very good to have on a server. Have you built anything like a 5 year uptime 1000+ concurrent users server with hot-patching every day? Have you even tried Java?
In Ask HN: Has anyone fully embraced an event-driven architecture?
Yes, I made my own open-source event driven platform: http://github.com/tinspin (rupy is the foundation and fuse is an example implementation tested with 350.000 users and 5 years uptime) The learnings where 2-fold: 1) You need async-to-async capable db clients so that you use 4 threads (potentially on separate cores) for each browser <-> server <-> database roundtrip. Since most databases don't have async capable clients I wrote my own database too: http://root.rupy.se 2) You should use a VM + GC language so that you can use atomic shared memory between cores, that way any core can handle any request efficiently (and access other users memory). This part is very hard to prove in theory, but in practice I'm baffled by how well Java performs, you can find three quotes that I managed find here: https://github.com/tinspin/rupy/wiki Finally g
Read the rest
etting threads to cooporate on things is hard and you cannot debug it with any tools, instead you have to use "trial and error" until is sort of works all the time.
In Ask HN: Has anyone fully embraced an event-driven architecture?
My app server has had non-blocking IO on regular OS threads for 10 years. To hide things in "virtual threads" does not do you any favours in the long run because it just adds complexity; you need to understand things as close to the metal as possible to make it work as good as it can work: http://github.com/tinspin/rupy To not use async. is really bad, you are wasting so much CPU. Even in a async. scenario just copying memory from user space to kernel and back takes 30% of the CPU at full 100% utilization, imagine having all those context switches too!
In Networking I/O with Virtual Threads – Under the hood
Nope, the source code is linked and it's compact enough that you should be able to learn everything in about an hour. But here is the only documentation I have written so far: https://github.com/tinspin/rupy/wiki/Storage To see it in action with source: http://fuse.rupy.se (multiplayer system prooven with 350.000 customers and 5 years uptime) TLDR: It's my own database I made after using MySQL, Postgres, Oracle for 10 years (and building my own ORM with GUI design tool: http://move.rupy.se/file/logic.html). It out-scales everything on the planet but it has disk-space issues (that can be fixed with compression 100x but that adds complexity so I'll do it when my SSDs run out of space). It uses this old goodie for authentication: https://datatracker.ietf.org/doc/html/rfc2289
In Cloud-Native Database Systems (2021)
I made my own HTTP app. server and distributed JSON database: https://github.com/tinspin/rupy On top of this I have made many projects and I still use all of them today even 10 years later, some favourite: http://fuse.rupy.se (multiplayer system) http://tentacle.rupy.se (digg) http://sprout.rupy.se (wordpress) http://talk.binarytask.com (reddit) I also made my own cloud service both with my own hardware and on top of GCP: http://host.rupy.se (raspberry 2 cluster) http://host.binarytask.com (GCP)
In Ask HN: What are some tools / libraries you built yourself?
I use hot-reloading of tiny modules to get turnaround below 1 second on all my projects, server and client: My Java HTTP server hot-deploys a .jar containing new code with a simple classloader: https://github.com/tinspin/rupy My C+ 3D MMO engine uses .dll/.so hot-reloading so that the game code can change while the engine is running, it's not released yet: http://talk.binarytask.com/task?id=5959519327505901449
In Crazy fast build times, or when 10 seconds starts to make you nervous (2012)
The things you said in your comment above are untrue for very fundamental reasons. This isn't a judgement call of the best techniques based github histories. > I minted Joint Parallel and gave the definition! That means it's nonsense. It is an oxymoron, it contradicts itself. Parallelism by definition is about separation of dependencies and synchronization. Join implies the exact opposite. That's like saying Bright Black while telling people you invented a new color space. It is a hiccup to being taken seriously (to put it mildly). You have said stuff like 'java doesn't crash (usually)' and that multi-threading rendering adds at least 10 frames of latency to a game. Statements like these are not just incorrect, they indicated a lack of understanding by thinking mostly orthogonal concepts are somehow at the mercy of each other. I loo
Read the rest
ked at your link. The first file I opened says "non-blocking and asynchronous" in the first line of the comment. https://github.com/tinspin/rupy/blob/master/src/se/rupy/http... Your methods that are supposedly doing this use the synchronize keyword whose purpose is to "block (suspend execution)" of other threads that call the same method until the first thread is done. https://docs.oracle.com/javase/tutorial/essential/concurrenc...
In “Is Parallel Programming Hard, and, If So, What Can You Do About It?” v2 Is Out
Well, there was a real-time thing bought by Sun from Sweden but I'm still unclear as to how much of that has made it into the open-source part of the JDK. Time will tell! Joint Parallelism is a term that I invented, it means loosely defined: if two threads can read and write to the same memory at the same time without it causing too much loss... basically you need atomic concurrency which is only really efficient on a complex memory model VM with GC if you want high level language support: "While I'm on the topic of concurrency I should mention my far too brief chat with Doug Lea. He commented that multi-threaded Java these days far outperforms C, due to the memory management and a garbage collector. If I recall correctly he said "only 12 times faster than C means you haven't started optimizing"." - Martin Fowler https://martinfowler.com/
Read the rest
bliki/OOPSLA2005.html "Many lock-free structures offer atomic-free read paths, notably concurrent containers in garbage collected languages, such as ConcurrentHashMap in Java. Languages without garbage collection have fewer straightforward options, mostly because safe memory reclamation is a hard problem..." - Travis Downs https://travisdowns.github.io/blog/2020/07/06/concurrency-co... I'm not an expert, I can't explain why these things are true, because I'm trying to make something useful on top of C/Java instead of going too deep. But what I do know is that my app. server kicks everythings ass to the stone age in terms of performance and ease of use: https://github.com/tinspin/rupy It's facinating to see humans struggle with the wrong tools, and defending those same tools without even trying the alternatives (I have also worked with perl, PHP and C# so I know why those are bad). But I'm sure time will flush the bad apples out eventually, specially when electricity prices go up.
In Why asynchronous Rust doesn't work
This has been my primary focus for two decades, I litteraly can't work in slow environements: 1) I encourage people to use JavaSE on the server and hot-deploy to the servers directly with async. non-blocking: http://github.com/tinspin/rupy 2) For clientside: mostly C syntax (compiled with C++ compiler) is your best option and I recently made a in-app debugger for Windows: http://move.rupy.se/file/stack.html (this delivers something much worse than a Java stacktrace but as good as it gets without a VM). I also hot-deploy the C/C++ app code with a .dll to my .exe and the debugger works for that hot-deployed .dll too! On linux the .so hot-deploy works as well, the only reason I have not taken the addr2line source to port the in-app debugger is that I know which hardware I'm working on as I only plan to ship linux on ARM! Fight features where
Read the rest
you can, in this case limit your porting and exposure to unknown unknowns! Potentially I can hot-deploy the client .dll/.so over my hot-deployed server pipeline, making the platform a distributed real-time system where you can patch the native code in real-time remotely while users are using your app! Mostly usable for development I guess (¯\_(ツ)_/¯), but still really exiting!
In Maximizing Developer Effectiveness

MAKE YOURSELF AT HOME

A few shortcuts

/
Search the collection
?
Open this guide
Esc
Close dialogs and navigation

Your saved repositories and interests stay in this browser.