LinuxDoors AppImage Store
LinuxDoors Games
Games from LinuxDoors, each a single self-contained AppImage — the whole game and the runtime it needs in one file that you download, mark executable and run. Nothing to install, nothing left behind, and it runs the same on Debian, Ubuntu and other Linux distributions that can launch an AppImage. Back to the full AppImage Store.
4 games — free, one file, download and play.
Pool Table$0.00
The source stays open — free to read, build on and share. A price, where there is one, is not for the code as that is opensource. It is for the work around it: the servers and bandwidth that carry the download to you, and the hours a programmer spent designing, building, testing and looking after the app — hours that support them and the people they love, the same as any other profession in the workplace economy.
A share of what the paid apps earn goes back to the Linux and free-software projects they are built on. That community gave its work away so all of this should exist; paying the people who keep it alive is how it stays alive.
Anything marked $0.00 is exactly that — free, no asterisk.
Seven games of pool on a programmed-drawn table.
from LinuxDoors.com · created September 8, 2026
A LinuxDoors AppImage Software Product
This is an early version
Version 0.2, and the first game LinuxDoors has. It is a whole game and it plays properly, but it is early: there will be things in it that are wrong, and rough edges that only turn up once somebody other than its author is holding the cue. Version 0.2 is also the first version with sound -- see "The noise it makes" below. That is what the bug address is for -- bugs-report-pooltable@linuxdoors.com. If a shot does something a shot should not do, if a rule goes the wrong way, if it looks wrong or gets stuck or will not start, please write and say what you did and what happened. Every report is read, and the physics in it has already been rebuilt more than once on the strength of somebody saying "that is not how a ball behaves."
The seven games
Eight ball -- solids and stripes, then the black. Nine ball -- lowest ball first, and the nine wins it. Ten ball -- the called-shot version, on the tournament table. Straight pool -- every ball is a point. Cutthroat -- three players, and you pot other people's. Snooker -- reds and colours, on a twelve foot table. Practice -- a table, a rack and nobody keeping score. Each racks itself correctly and knows its own rules: which ball is on, what counts as a foul, when a scratch gives ball in hand, and who has won.
The table, from four sides
Straight down is the view you can actually aim in, and where the game opens. Raked tips it back to three quarters, for when you would rather look at the table than play on it. Free lets you walk around it -- drag with the right button to swing the eye about, the wheel to come closer. Down on the shot (press E) puts you behind the white and along the line of the aim, the way it looks when you are actually standing at a table: the eye about a foot and a half above the cloth, a stride back from the ball, stick coming toward you, and aiming turns the whole view with you. Once you strike, it holds absolutely still -- moving the view while the balls are moving makes it impossible to see what happened, so it does not. All four are painted by the same code from the same scene, so the balls sit where the physics says they are whichever one you are looking through.
How the balls behave
The part that has had the most work. Where you strike the cue ball decides what the white does: drag the spot on the little ball in the Strike panel -- hit it high and the white follows through, hit it low and it comes back (around two feet from normal potting range, less from further away, which is how a draw shot actually grades), hit it to a side for English, which bends the path an inch or three over a full table rather than the banana a first attempt produced. There is a button to put the tip back in the middle, because side left on by accident quietly bends every shot after it. The cloth is fast: rolling friction and sliding friction are separate, so a skidding ball scrubs off speed quickly while a rolling one barely fights anything, and the balls settle rather than stop -- the cloth lets go as a ball slows, so it eases out of its roll and creeps the last of it. Energy is accounted for: no collision hands out more than the balls brought into it, checked across thirty of them at every pace and strike, and the most any one made was 98%.
Playing against the computer
Three strengths, and they are honestly different: on a table with one ball to pot, the computer makes roughly one in ten, three in ten, or five and a half in ten. It looks for the shot it can see, works out the pace from how far the ball has to travel, and misses by an amount that depends on how good it is meant to be.
The controls
Point to aim. Hold the button and pull back to draw the power; let go to hit, and pull further for a harder shot. Left and right arrows turn the cue a little; Shift and arrows turn it a very little; Shift while aiming is fine aim when you are down on the shot. Space hits it. E gets you down on the shot or stands you back up. 0 shows the whole table; Ctrl+= and Ctrl+- come closer and back. Right-button drag looks around in the free view; the wheel comes closer, or walks you up and down the line when you are down on the shot. Ctrl+N racks them again. Down on the shot the mouse turns the aim at a steady rate rather than pointing at a spot on the cloth -- from behind the ball the cloth is no guide at all, and pointing at it made the stick unusably twitchy.
The noise it makes
There is not a recording anywhere in the program, for the same reason there is not a photograph. Four sounds, worked out rather than sampled. Ball on ball is very short and almost all attack -- phenolic resin is about the hardest thing anybody plays a game with, and two of them meeting is a click rather than a note. The tip on the cue ball is softer and lower, since leather and chalk aren't resin; the two are told apart by timing, not by guessing -- the first contact of a shot involving the cue ball is the one the cue made, every later one is two balls. The cushion is dull and quick with no ring at all, which is the whole difference between a cushion and a rail; the pocket is the ball off the shelf and the run down behind it, two layers together. How loud each one is comes from how fast the balls were closing, taken before the exchange rather than after -- a kiss and a break are the same kind of event and must not be the same noise. Sound is a toggle (Game menu, or S), and it tells the truth: on a machine with no sound server it says so and takes its own tick off, rather than pretending to work.
On the command line
Pool_Table.AppImage opens on the eight ball table; add a game name to start on a different one -- nine, ten, straight, cutthroat, snooker or practice. Pool_Table.AppImage --version and --help do what they say. Settings live in ~/.config/pool_table/pool_table.save and are written when the game closes; deleting that file puts everything back as it started.
Running it -- nothing to install
Download the AppImage, make it executable, run it -- optionally with a game name to open a different table. On LinuxDoors, which has no FUSE, run it the way LinuxDoors runs any AppImage: ./Pool_Table.AppImage --appimage-extract-and-run, or through linuxdoors-run-appimage, which does that for you and unpacks it once rather than on every launch.
Written for LinuxDoors, though nothing in it is specific to LinuxDoors -- it runs on Debian- and Ubuntu-type systems, and on any other Linux distribution that can run an AppImage.
Basketball$0.00
The source stays open — free to read, build on and share. A price, where there is one, is not for the code as that is opensource. It is for the work around it: the servers and bandwidth that carry the download to you, and the hours a programmer spent designing, building, testing and looking after the app — hours that support them and the people they love, the same as any other profession in the workplace economy.
A share of what the paid apps earn goes back to the Linux and free-software projects they are built on. That community gave its work away so all of this should exist; paying the people who keep it alive is how it stays alive.
Anything marked $0.00 is exactly that — free, no asterisk.
An open court, a hoop and a crosshair on the glass, drawn rather than photographed.
from LinuxDoors.com · created September 19, 2026
A LinuxDoors AppImage Software Product
This is an early version
Version 0.2. It is a whole game and it plays properly, but it is early, and there will be rough edges that only turn up once somebody other than its author is the one shooting. Bug reports go to bugs-report-basketball@linuxdoors.com -- if a shot does something a shot should not do, please write and say what you did and what happened.
Aiming on the square
The crosshair sits on the painted square on the glass, not in a box in the corner of the screen -- that square is what a person aims at, which is why it is painted on the backboard in the first place. Across is across, and higher up the square is deeper into the ring, exactly what higher on the glass does to a real shot. It tells the truth: the speed the ball leaves at is solved backwards from the spot picked, so where the crosshair is, is where the ball goes. And it says what it would do, in a word -- "in" when the ball drops, "ring" when it is on the rim, "glass" when it is going off the board -- worked out from two hundred and thirty-one real flights simulated when the court is built, not a guess. The sweeping lines can be turned off on their own, leaving the crossing and the shaded scoring patches; in the pointing modes (Pool and Flick) the targeter is just a ring following the mouse over the one part of the picture worth looking at.
Nine ways to shoot
Pool (point and pull back, the way a cue works -- the one it starts on), Drift (the crosshair wanders on its own and you press when you like the look of it), Flick (flick up with the mouse and click to let go), Arcade (two sweeping lines, one press stops both, then pull back and shoot), Arcade #2 (the crosshair never stops -- hold and drag upwards to wind the throw up, and the aim is read at the instant you release, the hardest of the modes because hesitating costs something), Quick (the same two lines with the pull already loaded, so letting go at once takes the shot the crosshair already promised), Classic (across first, then depth, and it shoots itself), Snap (both lines, one press, shot for you), and Pitch (one line at a time, then shoot it yourself). The wandering in Drift is two sines of unrelated speed on each axis -- close enough to repeating to be learnable, far enough that it never quite does.
The shot, and why the arc is the fixed thing
Pull back and let go, or hold Space and release. What is held fixed while the shot is solved is the arc, not the release angle -- the obvious choice is provably the wrong one. At a fixed angle the speed needed to clear the ring's height is not a straight line against distance; it has a minimum, and either side of it the same speed answers two different distances, one of which is the ball still on its way up. Holding the arc fixed instead -- the ball always clears the ring by the same amount at the top of its flight -- gives one answer for every distance, and it is also the truer description of a real shooter, who keeps their arc and lets the angle flatten as they move back.
The glass
The backboard is a real surface and banking is a real shot -- half the depth track scores, eight inches of it straight through and thirteen and a half banked in off the glass. The contact is computed on the skin of the ball, not its center, so it doesn't come off five inches too deep. A ball can bank more than once, since going up into the glass and back down through it is a real and fairly common way to score. And the board's stiffness was tuned against real behavior -- the band of deep aims that actually bank in is fourteen times wider than an earlier, softer setting gave. The rim gives back only about a quarter of what it was given, so a rattle settles instead of dancing forever.
What counts as a basket
One thing, and only this: the ball crossed the plane of the ring on its way down, with its whole width inside. Nothing below the ring counts, whatever it is doing there. That is worth stating because the game used to get it wrong, in the one place hardest to see -- a ball that had caught the ring and rattled out was still asked, every frame, whether it was somewhere below the ring and falling and over the middle, which is also true of a ball a foot underneath the hoop on its way down. The game now works back to the exact instant the ball passed the ring's own height and asks there instead, so a bounce comes off the ring itself rather than off a spot the ball had already gone by. Measured over 7,503 shots -- every aim point on the crosshair's grid at three different speeds -- 64 baskets that had been awarded with the ball as much as 41 inches below the rim are gone, and no basket is now given anywhere but at the ring.
The court, the camera, and the sound
The court is open -- no arcade cage, just a hoop on an NBA-sized floor across six real surfaces (Maple, Oak, Walnut boards; Slate, Blacktop, Painted outdoor courts). Four views share one camera and one drawing pass: from above, raked (the one to play in), from the free-standing shooting line, and a free 3D view you can drag around. The line-of-sight view alone took real measurement to get right -- the whole backboard, the ring, some floor, and the ball in frame for the whole flight, all at once. Every sound in the game -- the ring, the glass, the net, the end-of-game horn -- is synthesized rather than recorded, and computed from the ball's own predicted flight so it arrives at the ear exactly as the ball arrives, not a beat behind. Measured over 231 shots and 464 real contacts: every contact makes its sound, and the sound lands a median 99 milliseconds ahead of the moment of contact -- which is what makes it feel simultaneous rather than delayed.
Seven games, a machine opponent, and the controls
Rapid fire (45 seconds, ball comes straight back, every shot worth the same so nothing tempts you to stop and think), Frenzy (60 seconds, last ten worth double), Twenty-five (a straight 25 shots), Around the World (seven spots on the floor, make one to move to the next), Around the 3 Point Line (played in Free 3D from any angle you turn the court to -- pinned to the arc the whole time, so every basket is a three), Around the Arc (the same shooting made into a round -- seven spots on the arc from baseline to baseline, the court turning to face each one for you), and Knockout (goes until a shot misses). A machine opponent takes alternate shots in the fixed-count games at three honestly different skill levels. Controls: Space to shoot (hold and release), arrow keys or the mouse to lean the ball once it's airborne, 1-4 to switch camera views, S for sound, right-drag to orbit the views that turn, the wheel to zoom, Ctrl+N for a new game, F1 for how to play.
Shooting from anywhere on the arc
The two arc games work by solving every shot in the shooter's own frame -- across, along, up, with the ring straight ahead -- then turning that frame about the ring to put it on the court. Since the ring is a circle, that costs almost nothing: the arc, the power bar and the crosshair are the same arithmetic wherever you're standing. The backboard is the one exception, since a board isn't a circle -- it's checked where it actually is rather than in the shooter's frame, and the result falls straight out of the geometry: aims that bank in run 28 straight on, 24 at thirty degrees, 23 at sixty, and just 9 at ninety, where the board is nearly edge-on -- exactly like a real court.
Running it -- nothing to install
Python, Qt and PySide6 all travel inside the AppImage -- nothing on the machine is used and nothing on the machine can conflict with it. Download it, make it executable, and run it: ./Basketball.AppImage (add --game rapid --aim quick to jump straight into a mode). On LinuxDoors, which has no FUSE, run it the way LinuxDoors runs any AppImage: ./Basketball.AppImage --appimage-extract-and-run, or through linuxdoors-run-appimage, which does that for you and unpacks it once rather than on every launch.
Written for LinuxDoors, though nothing in it is specific to LinuxDoors -- it runs on Debian- and Ubuntu-type systems, and on any other Linux distribution that can run an AppImage.
Skee Ball$0.00
The source stays open — free to read, build on and share. A price, where there is one, is not for the code as that is opensource. It is for the work around it: the servers and bandwidth that carry the download to you, and the hours a programmer spent designing, building, testing and looking after the app — hours that support them and the people they love, the same as any other profession in the workplace economy.
A share of what the paid apps earn goes back to the Linux and free-software projects they are built on. That community gave its work away so all of this should exist; paying the people who keep it alive is how it stays alive.
Anything marked $0.00 is exactly that — free, no asterisk.
The arcade alley game of Skee Ball, on a lane drawn with the program.
from LinuxDoors.com · created September 19, 2026
A LinuxDoors AppImage Software Product
This is an early version
Version 0.1, and the second game LinuxDoors has. It is a whole game and it plays properly, but it is early, and there will be rough edges that only turn up once somebody other than its author is the one rolling the ball. Bug reports go to bugs-report-skee_ball@linuxdoors.com -- if a ball does something a ball should not do, please write and say what you did and what happened.
The targeter
Two lines at right angles, in a box in the corner of the screen -- one runs side to side and says where across the plate the ball will land, the other runs up and down and says how far up the slope. Where they cross is where the ball goes, with a miniature plate under the tracks showing which hole that is. It isn't drawn across the plate itself, on purpose: that would put a line through the one thing worth looking at. And it goes there -- the throw is solved backwards from the crossing, so the crosshair is a promise rather than a suggestion. Every one of 143 test aims spread over the whole plate landed in exactly the hole it was aimed at.
Six ways to use it
Pool (point at the plate and pull back, the way a cue works -- the one it starts on), Flick (flick up with the mouse and click to let go), Arcade (both lines at once, one press stops them, then throw), Arcade #2 (no lines at all -- the aim wanders on its own, hold and drag upwards to wind the throw up, and the aim is read at the instant you release), Classic (across first, then up, and it throws itself -- two timed presses, the way the video cabinets did it), Snap (both lines, one press, thrown for you -- the quickest and least forgiving), and Pitch (one line at a time, then throw it yourself). When both lines sweep at once they run at deliberately unrelated speeds and start at opposite ends of their tracks, so the fastest press isn't automatically the worst throw. Sweep speed -- gentle, normal, quick, unkind -- is the actual, honest difficulty control.
The throw, and why power is the height
Pull back with the mouse and let go, or hold Space and release. How hard you throw isn't a separate difficulty -- it's the up-and-down half of the aim, since on a real machine the ramp never moves and only speed decides whether a ball drops into the ten or sails into the fifty. The power bar stands upright beside the lane with a green band marking exactly the speed the crosshair asked for: pull to the band and the ball lands on the crossing, pull past it and it lands high, fall short and it lands low -- the same aim at 80% power lands fourteen inches lower on the plate.
Leaning on it, and the sound
Once the ball is rolling, moving the mouse or the arrow keys leans it left or right -- worth about six inches by the time it reaches the plate, enough to save a shot between neighboring holes without undoing a bad aim. Nothing about it is painted over the lane; what the lean is doing shows in the targeter box instead, and when a ball drops the whole plate lights up, gold for a hundred and green for the rest. Every sound -- the ball on the boards, the drop, the plate -- is synthesized rather than recorded and worked out from the ball's own predicted flight, called about 99ms ahead of contact so it lands on the ear exactly as the ball lands on the plate, not a beat behind.
Four games, a machine opponent, three views
Nine balls (the standard frame), Rush (90 seconds, get as many away as you can), Hundreds (nine balls, only the two corner holes count), and Knockout (goes until a ball scores nothing). A machine opponent takes alternate rolls in the fixed-count games, picking a hole and then having to stop the lines itself -- averaging a bit over 100 across nine balls at easy, about 350 at fair, and over 500 at hard. Three camera views share one camera and one drawing pass: from above (the plan), raked (standing at the machine, the one to play in), and a free 3D view you can drag around with the right mouse button, tipping and turning the machine itself rather than an abstract camera.
The physics
The ball rolls the lane losing a little to friction, climbs the ramp losing five-sevenths of what a sliding thing would lose (a rolling sphere's real share, since it carries energy in its spin too), leaves the lip at the ramp's own angle, and flies as ordinary ballistics onto a sloped plate. The holes are sized correctly -- a hole only takes a ball if the whole ball fits, which at true dimensions leaves under an inch of room in the fifty, exactly why the targeter has to tell the truth rather than approximate.
Running it -- nothing to install
Python, Qt and PySide6 all travel inside the AppImage -- nothing on the machine is used and nothing on the machine can conflict with it. Download it, make it executable, and run it: ./Skee_Ball.AppImage (add --game rush --aim classic to jump straight into a mode). On LinuxDoors, which has no FUSE, run it the way LinuxDoors runs any AppImage: ./Skee_Ball.AppImage --appimage-extract-and-run, or through linuxdoors-run-appimage, which does that for you and unpacks it once rather than on every launch.
Written for LinuxDoors, though nothing in it is specific to LinuxDoors -- it runs on Debian- and Ubuntu-type systems, and on any other Linux distribution that can run an AppImage.
Bowling$0.00
The source stays open — free to read, build on and share. A price, where there is one, is not for the code as that is opensource. It is for the work around it: the servers and bandwidth that carry the download to you, and the hours a programmer spent designing, building, testing and looking after the app — hours that support them and the people they love, the same as any other profession in the workplace economy.
A share of what the paid apps earn goes back to the Linux and free-software projects they are built on. That community gave its work away so all of this should exist; paying the people who keep it alive is how it stays alive.
Anything marked $0.00 is exactly that — free, no asterisk.
Ten pins and ten frames, on a lane drawn with the program.
from LinuxDoors.com · created September 19, 2026
A LinuxDoors AppImage Software Product
This is an early version
Version 0.1. It is a whole game and it plays properly, but it is early -- there will be things in it that are wrong. That is what the bug address is for -- bugs-reports-bowling@linuxdoors.com. If a ball or a pin does something it should not do, please write and say what you did and what happened.
Aiming, and rolling it
Point down the lane and the ball goes there -- a dashed line shows the line it will take, with a ring where it crosses the arrows, which is the board a bowler would actually call out loud. Pull back and let go, one movement, the way the cue works on the pool table, and that is what the game starts on. Sweeping-line arcade aim modes are in the Aim menu for anyone who wants them, including Arcade #2, which never locks -- the line wanders on two sines of unrelated speed, and the board is read at the instant you let go, so the pull is not a job done in peace. Only one line, not two: bowling has one thing to aim, where across the lane, and how far is answered by pace instead.
The pace is a choice
The green band on the power bar marks the pace that carries best -- marked, not enforced, because pace is a real decision. Slower gives the ball longer to bend, so more hook; faster bends it less and hits harder. That trade is in the arithmetic rather than bolted on: how far a lean moves the ball is divided by how fast it is going, since a sideways push does more to a path the longer the ball is under it.
The hook is yours
Move the mouse or the arrow keys left or right while the ball is rolling and it curves that way -- that is the whole of the hook, and it belongs to the player rather than the ball on purpose. A hook built into the ball would mean the line shown was never the line delivered; keep your hands still and the ball arrives exactly where the line said, and every inch of bend after that is something you did.
The pins
A pin has a body, not a footprint -- fifteen inches of wood on a two inch foot, carrying a tilt and a line from foot to head that everything touching it actually touches. The ball against a pin is a sphere against that segment; a pin against a pin is one segment against another, walked rather than solved. Where the ball strikes matters as much as that it strikes -- a hit low drives a pin along the deck, the same hit high takes the head out from under it. Once a pin is leaning, gravity finishes the job like an inverted pendulum, going over past forty-five degrees with nothing bringing it back. Two numbers -- how much pace a pin takes, and how slick the deck is -- decide whether any of it feels like bowling; thirty-two pairs were tried before landing on the one where a slow ball tops out and a fast one carries. And the strike is not down the middle -- a ball straight at the head pin leaves six or seven standing, the same as on a real lane, because the pocket falls out of where the pins actually are.
The noise it makes
Five sounds, worked out rather than sampled, the same discipline as the sound in Pool Table. The ball down the boards is low, rough and long; the channel is hollower and higher, the sound of a ball that has already failed. The crash is four things at once -- a burst of hard broadband for the strike itself, the boom of the deck and the pit underneath, the wood of the pins in the middle, and forty small knocks crowded into the first quarter second, because ten pins do not fall at once. The whole of it sits in a room built from Schroeder's own 1962 reverberator arrangement (four feedback combs, two allpass filters, deliberately unrelated delays) so the crash rings the way a real alley -- boards, block, a high ceiling, nothing soft anywhere -- actually answers, rather than sounding like a chair leg dropped in a cupboard. How loud each sound is comes from how hard the thing arrived, so a trickled pocket hit and a full-speed strike are never the same noise. Sound is a toggle (Game menu, or S), and it tells the truth on a machine with no sound server rather than pretending to work.
The scoring
Ten frames, done properly -- a strike is ten plus the next two balls, a spare is ten plus the next one, and the tenth frame gives the extra balls to finish those with. Checked against the cases that catch programs out: twelve strikes is 300, ten five-and-fives is 150, nine-and-miss ten times is 90, three strikes then nothing is 60. Ten pin is the game itself; Nine pin no-tap counts a nine as a strike, the way some leagues really play it (twelve nines is 279); Best of three runs three racks and keeps only the best one.
Drawn, not photographed
One lamp, and everything shaded against it. The lane is thirty-nine boards drawn one at a time, each a shade different from its neighbour, with the oil shining down the middle two thirds and fading before the pins. A pin is a turned profile -- foot, waist, belly, neck, head -- drawn along its own axis wherever that axis happens to point, rather than as an upright shape that gets shorter. The ball takes a long smear of the lights above the lane rather than one round dot, and its finger holes turn with it. The lane itself is thirty feet rather than a real sixty, so the pins -- which are the game -- read clearly instead of shrinking to specks at the vanishing point; the hook rates are scaled to match, so a full hook still bends the same real distance at every pace regardless of lane length.
The rest of it
Three views share one camera -- from above, raked, and a free 3D view you can drag around with the right mouse button, tipping and turning the lane itself rather than an abstract camera; dragging in either of the other two views quietly switches to Free 3D rather than doing nothing. A machine opponent bowls alternate frames at easy, fair or hard. Maple, oak or walnut lanes. Tickets, a prize wall, and best games kept with the date. Settings live in ~/.config/bowling/bowling.save.
Running it -- nothing to install
Python, Qt and PySide6 all travel inside the AppImage -- nothing on the machine is used and nothing on the machine can conflict with it. Download it, make it executable, and run it: ./Bowling.AppImage (add --game nofuss to start a no-tap game directly). On LinuxDoors, which has no FUSE, run it the way LinuxDoors runs any AppImage: ./Bowling.AppImage --appimage-extract-and-run, or through linuxdoors-run-appimage, which does that for you and unpacks it once rather than on every launch.
Written for LinuxDoors, though nothing in it is specific to LinuxDoors -- it runs on Debian- and Ubuntu-type systems, and on any other Linux distribution that can run an AppImage.