pangea.stanford.edu

Unix is a family of multitasking, multi-user operating systems, not a single product you download. When an open-source game like Heroes lists "Unix" support, it usually means the source code can be compiled and run on Unix-like systems such as Linux, FreeBSD, Solaris, SunOS, or IRIX. Whether you can actually play depends on whether a binary exists for your system or whether you can build the game from source with a compiler and the required libraries.

Unix as a family, not a download

Unix began as an operating system developed at Bell Labs and later branched into many commercial and academic variants. Over time, the term came to describe both:

• Systems derived from the original Unix code, such as Solaris or IRIX.
• Unix-like systems that follow similar design conventions and APIs but were written independently, such as Linux and FreeBSD.

The Heroes project page reflects this breadth. Its keyword list includes unix, linux, windows, mingw32, solaris, sunos, freebsd, and irix — a mix of operating system families and specific platforms. That list is a signal of where the code has been ported or is expected to build, not a promise that every listed system has a ready-to-run package.

A useful way to think about it: Unix is closer to a specification and a design tradition than to a single installer. Each implementation — Linux, FreeBSD, Solaris — has its own kernel, tools, and package management, even though they share concepts like a hierarchical file system, processes, and a command-line shell.

Why projects list Unix-like platforms separately from Windows

Open-source projects often separate Unix-like targets from Windows because the build and runtime environments differ substantially:

For Heroes, the presence of mingw32 alongside unix, linux, and freebsd suggests the project maintained separate build paths for Windows and for Unix-like systems. Listing them separately helps users find the right download or build instructions instead of assuming one package works everywhere.

Unix is not one downloadable thing

Because Unix is implemented by many systems, there is no single "Unix download" that covers all of them. A game that supports Unix-like systems may provide:

• Prebuilt binaries for specific systems or distributions.
• Source code that you compile yourself.
• Both, with binaries covering the most common platforms and source covering the rest.

The Heroes page describes the project as concentrating on "cleaning the code and porting the game to the various operating systems available," with the goal of a version 1.0 as a "clean and portable base." That language indicates portability work was ongoing rather than finished, so availability of ready binaries for any given Unix-like system should be checked on the download page rather than assumed.

How portable source code gets built on Unix-like systems

When a project distributes source code rather than binaries, running it on a Unix-like system generally follows this pattern:

1. Confirm prerequisites. You need a C or C++ compiler, a build tool such as make, and any libraries the game depends on. The exact list comes from the project's build documentation.
2. Obtain the source. Download the source archive from the project's download page.
3. Configure the build. Many Unix-oriented projects include a configure script that checks your system for compilers and libraries and generates build files. The expected result is a report of what was found and what is missing.
4. Compile. Running make builds the executable. Errors at this stage usually point to missing headers or libraries.
5. Run and verify. Launch the resulting binary. If it starts and reaches the main menu, the build succeeded; missing data files or sound libraries typically show up as startup errors.

For Heroes specifically, the page mentions 12 original sound tracks, 94 levels across 10 tile sets, and a level editor, so a working build also needs the game's data files in place. The page does not document the exact build commands, so those should come from the manual or the source archive's own instructions.

What Unix support means in practice for Heroes

The practical takeaway for a player is conditional:

• If a binary exists for your system, download and run it, checking that required libraries are installed.
• If only source is available, you need a compiler and build tools, and you should expect to resolve dependency issues yourself.
• If your system is listed only as a keyword, treat that as a hint that the code has been considered for that platform, not as a guarantee of a working package.

The Heroes page also notes that the original MS-DOS version is unmaintained and "should be considered obsolete," and that the current code is distributed under the GNU General Public License version 2. That license means the source is available for building and modification, which is exactly what makes porting to multiple Unix-like systems feasible in the first place.

In short, "Unix support" for a game like Heroes describes a family of target systems and a source-based path to running the game, not a single download that works everywhere. Check the download page for your specific system, and be prepared to build from source if no binary is provided.

The GPL (GNU General Public License) is a software license that grants anyone the freedom to run, study, modify, and redistribute the licensed program, provided that derivative works are released under the same license. For a user of AAT Another Activity Tracker, this means the app's source code is publicly available and can be inspected, changed, and shared. For a developer, it means any modified version you distribute must also carry the GPL. The license does not require you to publish your own private changes — only distributed versions trigger that obligation.

The Four Freedoms the GPL Guarantees

The GPL is built around four freedoms, defined by the Free Software Foundation:

1. Run the program for any purpose.
2. Study how it works and change it (access to source code is a precondition).
3. Redistribute copies to others.
4. Improve the program and release your improvements to the public.

AAT Another Activity Tracker fits this model directly. Its source is published on GitHub, and a binary build is distributed through F-Droid. That combination — public source plus a redistributable binary — is exactly what the GPL is designed to enable.

Copyleft: The Key Difference From Permissive Licenses

The GPL is a copyleft license. Permissive licenses such as MIT or Apache-2.0 let you take the code, modify it, and ship it under a different (even proprietary) license. The GPL does not.

So if someone forks AAT, adds a feature, and distributes the result, they must make that modified source available under the GPL. They cannot turn it into a closed-source paid app.

How This Plays Out for an Android App on GitHub and F-Droid

For AAT specifically, the practical consequences are:

• You can install it freely. F-Droid hosts the binary; GitHub hosts the source. No license fee is implied by the GPL itself.
• You can build it yourself. Because the source is on GitHub, you can compile your own APK from the same code.
• You can fork and modify it. Want to change the cockpit view or the GPX editor? The GPL permits it.
• If you distribute your fork, you must share the source. Publishing a modified APK to a store or sharing it with others triggers the copyleft requirement.
• F-Droid's model aligns with the GPL. F-Droid builds from source and distributes binaries, which is consistent with the license's redistribution terms.

Common Misconceptions

• "The GPL forces me to publish my changes." Only if you distribute the modified software. Private modifications for personal use carry no publication obligation.
• "GPL software can't be sold." It can. The GPL permits selling copies; what it prevents is distributing modified versions without source.
• "GPL and open source are the same thing." The GPL is one open-source license among many. Open source is the broader category; copyleft is the specific mechanism the GPL uses.
• "Using a GPL app makes my own project GPL." Merely using AAT does not affect your other software. The copyleft obligation attaches to derivative works of the licensed code, not to unrelated programs.

What to Check Before Reusing GPL Code

If you plan to build on AAT or any GPL project:

1. Confirm the exact version (GPLv2 vs. GPLv3) — the terms differ, especially around patents and anti-tivoization.
2. Check whether the project is "GPLv2 only" or "GPLv2 or later."
3. Verify that all dependencies are license-compatible.
4. Decide upfront whether you intend to distribute; that determines your obligations.

For an end user, the takeaway is simpler: the GPL is what makes AAT's source inspectable and its builds reproducible, and it keeps any public fork open to the same scrutiny.

A web mirror utility is software that downloads a website from the internet to a local directory and rebuilds its internal links so the copy can be browsed offline in any browser. HTTrack is a widely used open-source example: it recursively pulls HTML pages, images, and other files from a server, rewrites links as relative paths, and can update an existing mirror or resume an interrupted download. Use this approach when you need a readable, navigable copy of a site rather than a single-page snapshot.

How a mirror is built

The process has three stages:

1. Crawl. Starting from a URL, the utility follows links and downloads pages, images, stylesheets, scripts, and other files it finds. “Recursively” means it keeps following links within the site rather than stopping at the first page.
2. Store. Files are saved into a local directory that reproduces the site's folder structure, so paths stay organized.
3. Rewrite links. Internal links are converted to relative paths. This is the step that makes the mirror usable: a link that pointed to https://example.com/docs/page.html becomes a local relative reference, so clicking it in the downloaded copy opens the saved file instead of going online.

The result is a local site you can open in any browser without a network connection.

What you can do with it

• Offline reading: Keep reference material, documentation, or articles available without internet access.
• Archiving: Preserve a site's content as it existed at a point in time.
• Site backup: Keep a local copy of a site you own or maintain.
• Multi-site mirrors: Mirror several sites together so you can jump between them locally.
• Incremental updates: Update an existing mirror to pick up changes instead of downloading everything again.
• Resume: Continue an interrupted download rather than starting over.

HTTrack's own description notes it is fully configurable with integrated help, and that mirrored sites work with any browser.

Practical limits to plan for

A mirror is a copy of what the crawler can reach, not a perfect replica:

• Dynamic content: Pages generated by scripts or requiring login may not download correctly or may be incomplete.
• Scope control: Without limits, a crawl can pull far more than intended. Set depth, file-type, and domain restrictions before starting.
• Storage and time: Large sites take significant disk space and download time.
• Freshness: A mirror is a snapshot; use the update feature if you need current content.

Choosing an approach

For a first attempt, start with a small site or a limited section, confirm the local copy opens and links work, then expand scope.

DOS (Disk Operating System) was the command-line operating system that most IBM-compatible PCs ran before Windows became the dominant environment, and it's the platform nearly every classic PC game from the 1980s and early-to-mid 1990s was built for. Because modern 64-bit Windows, macOS, and Linux can't run those games natively, you play them through an emulator such as DOSBox, or through a site that packages the emulator and game together so it launches with a click. This article explains what DOS actually was, why emulation is necessary, and how to get a DOS game running — including the sound, speed, and fullscreen problems that trip most people up.

What DOS actually was

DOS is not a single product but a family of operating systems. The version that mattered for gaming was MS-DOS (Microsoft) and its close relative PC DOS (IBM), with compatible clones like DR-DOS and FreeDOS filling out the field. Key traits:

• Command-line interface. You typed commands at a prompt (C:\>) rather than clicking icons. Games typically launched by typing an executable name, e.g. PRINCE or DOOM.
• Real-mode memory model. Early DOS gave programs direct access to hardware and to a limited pool of conventional memory (640 KB), which is why so many games shipped with memory-configuration instructions for CONFIG.SYS and AUTOEXEC.BAT.
• Direct hardware access. Games talked straight to the sound card, graphics adapter, and input devices. That's what made them fast on period hardware — and what makes them fragile on modern machines, where the operating system mediates all hardware access.
• No multitasking. One program ran at a time. Later versions added limited memory management, but the model stayed fundamentally single-tasking.

Windows 3.1 and Windows 95 could run on top of DOS, and many games of that era shipped as DOS executables launched from within Windows. That's why a preservation project like Zomb's Lair lists DOS alongside Windows 3.1 and Amiga as separate platforms — they're genuinely different targets requiring different handling.

Why you need an emulator on a modern PC

A DOS game expects to own the machine: it writes directly to video memory, programs the sound chip, and reads the keyboard hardware. A modern OS forbids all of that. Three practical consequences:

1. 64-bit Windows cannot run DOS programs at all. The NTVDM (NT Virtual DOS Machine) that provided DOS support was dropped from 64-bit builds. On 32-bit Windows it still exists, but it's unreliable for games.
2. Timing breaks. DOS games often tied game speed to CPU clock speed. On a multi-gigahertz processor, a game designed for a 33 MHz 486 may run absurdly fast or refuse to start.
3. Sound hardware is gone. The Sound Blaster, AdLib, and Gravis Ultrasound cards these games target don't exist in modern machines, and the games don't know how to use what replaced them.

DOSBox solves all three by emulating a complete DOS PC — CPU, video, sound card, and all — inside a window. It's the standard tool, it's free and open source, and it runs on Windows, macOS, and Linux.

Where to get DOS games

You have two broad routes, and they differ mainly in how much setup you do yourself.

Preservation and curation projects occupy the second category. Zomb's Lair, for example, describes itself as "a passion project dedicated to bringing old classics to a modern audience, while eliminating all of the hurdles that that normally entails," and organizes its catalog by platform (DOS, Amiga, Windows 3.1) and by genre (Adventure, RPG). The value of that kind of packaging is precisely the configuration work — memory settings, sound setup, and speed calibration — done for you.

A note on the legal side, since it affects which route you choose: much of this material is abandonware — old commercial software whose publisher has stopped selling or supporting it. Abandonware is a community norm, not a legal category, and rights holders can and do re-release games commercially. Where a game is currently sold (on GOG, Steam, or elsewhere), buying it is both the safer and usually the easier path, since those storefronts ship pre-configured DOSBox builds too.

Running a DOS game: the basic steps

If you're configuring DOSBox yourself, the workflow is the same for almost every game.

1. Install DOSBox for your platform and note where you put your game folder. Keep paths short and free of spaces — C:\DOS\GAMES\GAMENAME rather than a deep folder with spaces in the name. DOS itself had no concept of long filenames.
2. Mount a drive. At the DOSBox prompt, MOUNT C points an emulated drive letter at a real folder. The expected result is a confirmation message; if you get an error, the path is wrong.
3. Switch to that drive and change into the game directory.
4. Run the game's setup utility first if it has one (commonly SETUP.EXE, INSTALL.EXE, or SOUNDSET.EXE). This is where you tell the game which sound card to use — pick Sound Blaster or Sound Blaster 16 with the default port and IRQ values, which is what DOSBox emulates.
5. Launch the game by typing its executable name.
6. Adjust speed if needed. DOSBox's cycle count controls how fast the emulated CPU runs; raising it speeds a sluggish game up, lowering it slows a too-fast one down.

If you're using a pre-packaged release, steps 1–4 are already done. You launch a shortcut and the emulator starts with the right drive, sound, and speed settings.

Troubleshooting the usual problems

No sound, or sound only in some places. The game's own setup utility is almost always the culprit — it's still configured for a card DOSBox doesn't emulate. Re-run setup and select Sound Blaster. If the game predates sound-card setup utilities, it may only support PC speaker audio, which DOSBox emulates but which sounds thin by design.

Game runs too fast or too slow. This is the cycle setting. Games from the late 80s and early 90s are the most sensitive. Some front-ends let you bind hotkeys to raise and lower cycles while the game runs, which is the fastest way to find a stable value.

Fullscreen looks stretched or has black bars. DOS games ran at fixed resolutions like 320×200, which don't match a modern monitor's aspect ratio. Stretching fills the screen but distorts the image; leaving it unstretched preserves the original proportions. There's no correct answer — pick based on whether you prefer accuracy or a filled screen.

The game can't find enough memory. Classic DOS memory errors come from the 640 KB conventional-memory limit. DOSBox handles most of this automatically, but games with unusual requirements may need specific memory settings in the emulator's configuration file.

Keyboard or mouse doesn't respond correctly. DOSBox captures input when the game window is focused; releasing the capture (usually with a hotkey) returns control to your desktop. If a game needs a joystick, it has to be configured both in DOSBox and in the game's own setup.

What to take away

DOS was the command-line, single-tasking, hardware-direct operating system that defined PC gaming for roughly a decade, and its design is exactly why those games don't run on a modern machine without help. DOSBox emulates the whole environment; packaging projects remove the configuration burden on top of that. If you want to play rather than configure, start with a pre-packaged release and treat the game's own setup utility as the first thing to check whenever sound or speed misbehaves.

HTTrack is an open-source website mirroring utility that downloads a website's HTML pages, images, and other files from the server to a local directory, rebuilding links so the copied site can be browsed offline in any browser. It fits the need to archive a site or read it without a connection; it is not a tool for capturing content that only exists behind a login or is generated dynamically per request.

What HTTrack actually does

HTTrack works recursively: starting from a URL, it follows links and pulls the files it finds into a local folder, preserving the site's directory structure. Because links are rewritten to be relative, you can open the local copy in any browser and navigate it as if you were online. The project describes itself as an "easy-to-use website mirror utility" and a "web mirror utility" that can also be used as an offline browser.

The same page shows a concrete result of this process: an index of locally available sites, with an entry pointing to a mirrored path (sesd7/index/index.html) and a footer noting the mirror and index were "made by HTTrack Website Copier." That is the typical output — a browsable local index of what was captured.

Core capabilities

When it is a good fit

• Offline reading and archiving. You want a static copy of a site's pages and assets that opens without a network connection.
• Preserving a site's structure. You need the folder layout and internal links intact, not a flat dump of files.
• Long or interrupted downloads. The resume and update features matter when a mirror is large or a connection drops.
• Multiple related sites. Mirroring several sites together suits documentation sets or linked resources.

Limits to plan around

HTTrack copies what the server serves. Content that depends on a login, on server-side processing per request, or on scripts that fetch data at view time may not behave the same in the local copy. Before committing to a large mirror, test a small section first and open the result offline to confirm the pages you need actually work. Also check that mirroring the site is acceptable under its terms and any applicable rules.

Getting started

1. Install HTTrack (the Windows build is often referred to as WinHTTrack).
2. Create a new project, give it a local folder, and enter the starting URL.
3. Set limits — depth, file types, or included/excluded paths — so the mirror stays manageable.
4. Start the download and let it run; if interrupted, resume rather than restart.
5. Open the generated local index in a browser and verify navigation and assets.
6. Later, run an update against the same project to refresh the mirror.

The integrated help covers the configuration options if you need finer control over what gets captured.