spheredev.org

A JavaScript game engine is a library or framework that handles the repetitive parts of a game—rendering, input, audio, physics, and asset loading—so you write game logic instead of plumbing. You should choose one when your project matches its strengths and its maintenance status is healthy; you should skip one when your needs are simple enough that a canvas and a few hundred lines of code will do. Sphere is a concrete example worth examining: it is an open-source, cross-platform JavaScript-based engine with its own editor, and the community site describes it as "simple to learn, powerful to use."

What a JavaScript game engine actually does

Most engines cover the same core responsibilities, even if the API names differ:

• Rendering — drawing sprites, tiles, and text to a canvas or WebGL context, usually with a game loop that updates and redraws each frame.
• Input — translating keyboard, mouse, and gamepad events into something your game logic can query.
• Audio — playing sound effects and music, often with volume and channel control.
• Physics or collision — at minimum bounding-box or tile collision; some engines add a full rigid-body simulation.
• Asset management — loading images, sounds, and data files, and keeping them available by name.
• Packaging — bundling the game so it can be distributed and run outside your development folder.

Sphere's site lists a "simple but extensive, extendable API," a "comprehensive development environment," and "easy game packaging and distributing" as its main features. Those three items map directly onto the list above: the API is the rendering/input/audio layer, the environment is the editor and debugger, and packaging is distribution.

Build your own or adopt an engine

The decision usually comes down to how much of the list above you are willing to write yourself.

The trade-off is control versus speed. Writing your own loop gives you exactly the behavior you want and no dependency risk, but you will spend time on loading screens, input edge cases, and audio quirks that an engine already solved. Adopting an engine gets you to gameplay faster, but you inherit its API, its update cadence, and its platform limits.

How to evaluate a specific engine

Run the same five checks against any candidate, including Sphere.

1. API learning curve

Look for a "hello world" that fits on one screen. Sphere's site describes its API as "ideal for novice and advanced developers alike," and the community highlights "Modern JavaScript ES6 features," which matters if you want to write class, let, and arrow functions rather than older syntax.

2. Documentation and examples

Check whether there is a wiki, a reference, and finished games you can read. The Sphere site links a Wiki and lists games built with it, including Turbie's Super Happy Fun Hour Demo, Beaker, Zero's Impossible Fortress, Spectacles: Bruce's Story, Aquatis - Journey to Kiltos, and Kefka's Revenge. Playable examples are more useful than API docs alone because they show real structure.

3. Community activity

A forum or chat where questions get answered is the difference between a blocked afternoon and a solved problem. Sphere's community describes itself as "small, but very open," with forums and a Discord. Small is not automatically bad—it often means direct access to the maintainers—but verify that answers are recent before committing.

4. Platform and distribution support

Confirm the engine runs where your players are. Sphere is described as cross-platform across Windows, Linux, and Mac OS X, while its IDE, Sphere Studio, is listed as Windows-only. That split matters: you can ship to three platforms but may need a Windows machine to use the full editor.

5. Maintenance status

This is the check people skip and later regret. The Sphere site carries copyright lines through 2020 and notes that "Sphere is getting ready for the web!" via Oozaru, an HTML version for v2 games. Treat that as a signal to verify current activity yourself: check the latest forum posts, the wiki's last edits, and the download page before starting a long project.

Where Sphere fits

Sphere is a reasonable fit if you are building a 2D game, want an integrated editor and debugger rather than assembling a toolchain, and value an extendable API over a large ecosystem. The site's own framing—"Simple to learn, powerful to use"—and its history of 2D platformers and RPGs suggest that genre range. It is a weaker fit if you need 3D, if you require a Mac or Linux editor, or if you depend on a fast-moving ecosystem with frequent releases.

Common reasons engine projects fail

• The engine stops being maintained. The site's 2020-era copyright dates are exactly the kind of thing to check. An unmaintained engine still works until a browser or OS update breaks it.
• Platform limits bite late. Discovering that your editor is Windows-only after you have committed is avoidable—read the download page first.
• Packaging is harder than expected. "Easy game packaging" is a claim to test early with a throwaway build, not the week before release.
• The API fights your design. If you spend more time working around the engine than writing gameplay, the engine is the wrong shape for your game.

A practical way to decide

1. Write down your target platforms and whether you need 3D.
2. Pick two engines that match, plus the option of no engine.
3. Build the same tiny vertical slice—one moving sprite, one sound, one collision—in each.
4. Check each candidate's last release date and last answered forum question.
5. Commit to the one where the slice took the least fighting.

That slice will tell you more about the API and the documentation than any feature list, and it costs a weekend instead of a rewrite.

Open source means the software's source code is publicly available, so anyone can inspect, modify, and redistribute it. Zen Cart, the platform running this reptile supply store, is open-source e-commerce software: the store owner can read and change the code, and no license fee is paid to a vendor. That matters to a small shop because it removes per-sale or monthly software fees and allows deep customization — but it also means the owner (or a developer they hire) handles hosting, updates, and security. Note that "open source" here describes the store software, not the reptile foods and supplements sold on it.

Open source in plain terms

Proprietary store platforms typically charge a subscription or a percentage of sales and keep their code closed. Open-source platforms publish the code under a license that permits use and modification. In practice, for a store like this one:

• No license fee. You pay for hosting and your own time, not for permission to run the software.
• Full access to the code. Layouts, checkout flow, and product pages can be changed beyond what a theme editor allows.
• Community development. Fixes and add-ons come from contributors and other store owners, not only from one company.

What it looks like on this store

The page evidence shows a typical Zen Cart storefront: category navigation (Bee Pollen, Cat Grass, Chia Seeds, Dandelion, Sprouting Seeds, Supplements), an "All Products" listing, reviews, and an information block with About Us, Shipping & Returns, Privacy Notice, Conditions of Use, Order Status, Site Map, Gift Certificate FAQ, and Discount Coupons. That structure — categories, reviews, coupons, gift certificates, order status — is what the platform provides out of the box. The store also publishes care guides (Russian Tortoise Care, Box Turtle Care, Redfoot Tortoise Care) and growing instructions, which are content pages the owner added rather than built-in store features.

Benefits for a small pet supply shop

• Cost control. No platform subscription means a low fixed cost that doesn't scale with order volume.
• Custom catalog logic. A shop selling seeds, dried weeds, and supplements by weight can adjust product options, units, and shipping rules directly in the code.
• Content and commerce in one place. Care guides and growing instructions sit alongside the catalog, which supports the store's stated role of helping customers find foods for herbivore reptiles.
• No vendor lock-in on data. You can export and migrate your catalog if you decide to move.

Trade-offs to plan for

Deciding whether it fits your store

Choose an open-source cart like Zen Cart if you want no license fees, need code-level customization, and have either technical skills or a developer you can call. Choose a hosted subscription platform instead if you'd rather not manage hosting, patches, and upgrades, and you're comfortable paying monthly for that convenience. A middle path works for many small shops: run the open-source cart on managed hosting that handles server updates, and keep a developer on retainer for store-level changes.

If you're evaluating this specific store as a model, the useful signal is that a niche reptile supply shop can run a full catalog, reviews, coupons, and care content on open-source software without a platform fee — the cost shifts from subscriptions to maintenance.

TypeScript is a typed superset of JavaScript: every valid JavaScript program is also valid TypeScript, but TypeScript adds optional static types that a compiler checks before your code ever runs. You use it by installing the typescript package, writing .ts files, and compiling them to plain .js with the tsc command. It fits best when a codebase grows past a few files or several people, where catching type errors at build time is cheaper than debugging them at runtime. For a throwaway script, plain JavaScript is usually faster to write.

What TypeScript actually adds

TypeScript does not change how JavaScript runs. Browsers and Node.js still execute JavaScript, so the types are erased during compilation. What you gain is a checking pass:

• Static type checking — the compiler reads your annotations and flags mismatches before execution.
• Earlier error detection — mistakes like calling a method that does not exist surface in your editor or in tsc, not in production.
• Better tooling — editors use the type information for autocomplete, inline documentation, and safe rename/refactor operations.
• Self-documenting interfaces — function signatures and object shapes describe intent without extra comments.

The trade-off is a build step and some annotation overhead. Types are optional, so you can adopt them gradually.

The basic workflow

1. Install the compiler

npm install --save-dev typescript

This adds tsc to your project. You can also install it globally, but a local dev dependency keeps the version consistent across machines and CI.

2. Write a .ts file

function greet(name: string): string {
  return `Hello, ${name}`;
}

console.log(greet("Ada"));

The : string annotations tell the compiler what name and the return value must be. If you call greet(42), tsc reports an error instead of letting it fail silently at runtime.

3. Compile

npx tsc greet.ts

Expected result: a greet.js file next to the source, containing the same logic with the type annotations removed. That .js file is what Node.js or the browser runs.

4. Add a config file

For anything beyond one file, create a tsconfig.json so you do not repeat flags:

{
  "compilerOptions": {
    "target": "ES2020",
    "module": "ESNext",
    "strict": true,
    "outDir": "dist"
  },
  "include": ["src"]
}

Then just run npx tsc. strict: true turns on the stricter checks, including strictNullChecks, which is where most real-world type safety comes from. Turning it on later in a large project is painful, so enable it early.

Key features with examples

Type annotations

let count: number = 0;
let names: string[] = ["Ada", "Grace"];

Annotations can be omitted when TypeScript can infer the type, which it does for most assignments.

Interfaces

interface User {
  id: number;
  email: string;
  nickname?: string; // optional
}

function sendWelcome(user: User) {
  console.log(`Welcome, ${user.nickname ?? user.email}`);
}

An interface describes the shape an object must have. Passing an object missing id or email is a compile error.

Generics

function first<T>(items: T[]): T | undefined {
  return items[0];
}

const n = first([1, 2, 3]);      // n: number | undefined
const s = first(["a", "b"]);     // s: string | undefined

Generics let one function work across types while keeping the relationship between input and output. T is a placeholder filled in at the call site.

Using TypeScript in an existing JavaScript project

You do not have to convert everything at once:

1. Add typescript and a tsconfig.json with "allowJs": true so .js files are included.
2. Rename files to .ts one at a time, starting with the most central modules.
3. Add types to function boundaries first — parameters and return values — and let inference handle the internals.
4. Turn on strict once the obvious errors are cleared.

Most build tools and bundlers accept TypeScript through a loader or plugin, so you rarely need to run tsc by hand in a modern setup. In monorepos, tools like Lerna manage multiple JavaScript/TypeScript packages from one repository, and each package can carry its own tsconfig.json while sharing a base config. That is a common reason teams introduce TypeScript: a shared type contract between packages catches breaking changes at build time rather than at integration.

Common sticking points

• any everywhere — annotating everything as any disables the checks you installed TypeScript for. Prefer unknown and narrow it.
• Ignoring strictNullChecks — most runtime crashes come from null/undefined, which this flag catches.
• Types at runtime — TypeScript types do not exist after compilation, so you still need runtime validation for data from APIs, files, or user input.
• Build configuration drift — mismatched target/module settings between tsconfig.json and your bundler cause confusing errors; keep them aligned.

If your goal is safer JavaScript in a growing codebase, start with a tsconfig.json, enable strict, and convert files incrementally. If you are writing a small script that will not be maintained, plain JavaScript remains the simpler choice.

Sphere is an open-source, cross-platform game engine that lets you build games in JavaScript, paired with Sphere Studio, a Windows-only integrated development environment (IDE) for writing, running, and debugging those games. It fits developers who want a lightweight, JavaScript-first engine with a simple but extendable API — from beginners learning game logic to advanced developers who want direct control. The project is also moving toward the web: Oozaru is an HTML version of Sphere for v2 games, currently offered as a preview.

What Sphere actually is

Sphere is a game engine, not a full game framework with pre-built genre systems. Its stated design goals are:

• A simple but extensive, extendable API — you start with a small set of calls and extend as needed.
• A comprehensive development environment — Sphere Studio handles editing, running, and debugging.
• Easy game packaging and distributing — you can ship a finished game as a package rather than loose files.

It is described as open source, cross-platform, and FOSS/FLOSS, and it supports modern JavaScript ES6 features. The engine itself runs on Windows, Linux, and Mac OS X; Sphere Studio, the IDE, is Windows only.

The two pieces you install

Both are listed on the site's Download section, and other versions live on the Downloads Drive. If you are not on Windows, you can still run the engine, but you will be editing scripts outside Sphere Studio.

How you make a game with it

The workflow the site describes is:

1. Install Sphere and Sphere Studio. The engine runs the game; the IDE is where you build it.
2. Create your project in Sphere Studio. The IDE includes a map editor and a script editor — the site shows both in action.
3. Write game logic in JavaScript. Sphere supports modern ES6 features, so you can use current syntax rather than older JavaScript patterns.
4. Run and debug directly from the IDE. You do not need to launch the engine separately to test changes.
5. Package and distribute. Sphere is built so a finished game can be packaged for distribution rather than handed over as a folder of loose assets.

The expected result at each step is a runnable game you can test immediately, which is the main practical advantage of the IDE-plus-engine pairing.

What has actually been built with it

The site lists real games and demos, which is useful for judging what the engine handles in practice:

• Turbie's Super Happy Fun Hour Demo — a tech demo showing a different rendering style.
• Beaker — Sir Boingers, a challenging platformer built around constant bouncing.
• DaVince — Zero's Impossible Fortress, a platformer where you draw the platforms with the mouse.
• SDHawk, troupe, Salamando — Spectacles: Bruce's Story, an RPG with a complex battle system.
• Fat Cerberus — Aquatis - Journey to Kiltos, an RPG set in a cold, distant land.
• Metallix — Kefka's Revenge, a Final Fantasy 6 fan game.
• kr0 team — Development with Sphere.

The spread — platformers, RPGs, rendering demos, a fan game — suggests the engine is general-purpose rather than tied to one genre.

Moving to the web

Sphere is preparing a web version. Oozaru is an HTML version of Sphere for v2 games, and a preview is available. If you want your game to run in a browser, this is the path the project points to — but treat it as a preview rather than a finished, stable target.

Where to get help

The community is described as small but open and ready to answer questions. Support channels listed are the forums and a Discord server. The site also surfaces the latest forum post and latest wiki article, so the wiki is worth checking for reference material.

Practical things to know before starting

• Check your platform first. If you are on Linux or Mac, you get the engine but not Sphere Studio, so plan for editing scripts in another editor.
• Sphere Studio is the intended workflow. Running and debugging from the IDE is a core selling point; skipping it means giving up the main convenience.
• The engine is JavaScript-based, not a visual scripting tool. You will be writing code.
• The site does not state pricing. It describes the engine as open source and FOSS/FLOSS, but no pricing details appear in the page content — verify licensing and any costs on the official download pages before committing.
• The web version is a preview. Do not assume Oozaru is production-ready for a commercial release.

If you want a JavaScript game engine with a built-in IDE, a small extendable API, and a track record of finished games across several genres, Sphere is worth trying. If you need a browser-first engine today, or you are not on Windows and want a full IDE experience, the current setup will not match that out of the box.

FOSS stands for Free and Open-Source Software: software whose source code anyone can inspect, modify, and redistribute under the terms of its license. It is worth caring about if you want to verify what an app does with your data, keep using it without an account or subscription, or adapt it yourself. It is not the same as "freeware" (zero price, closed code), and "free" in FOSS refers to freedom, not cost — a FOSS app can still sell support, hosting, or perks.

The two words inside FOSS

FOSS bundles two overlapping traditions that are often treated as one:

• Free software — the emphasis is on the user's freedoms: run the program for any purpose, study how it works, modify it, and share copies or modified versions. The "free" is about liberty, which is why the common shorthand is "free as in speech, not free as in beer."
• Open-source software — the emphasis is on the development model: source code is publicly available and the license permits derived works. It is a more pragmatic framing aimed at businesses and collaboration.

In practice, a license that grants the four freedoms above is also open source, so the combined term FOSS (or FLOSS, adding "libre") is used when you want to cover both without picking a side in the philosophical debate.

Free, open source, and freeware are three different things

The practical test is not the price tag. A $0 download with hidden code is freeware, not FOSS. A FOSS project can charge for a hosted service or a "supporter" tier while the core app stays free — Audion, for example, describes itself as "free and open source" with a Supporter option where donations "unlock account sync perks," while the app itself lists "no subscriptions, no ads, no tracking."

What licenses actually require

The license is what turns "you can see the code" into "you are allowed to do something with it." Three families cover most cases:

• Permissive (MIT, Apache 2.0) — you can use, modify, and ship the code in closed products, usually as long as you keep the copyright notice. Apache 2.0 adds an explicit patent grant.
• Copyleft (GPL, AGPL) — if you distribute a modified version, you must release your changes under the same license. AGPL extends this to software offered over a network, which matters for self-hosted servers.
• Weak copyleft (LGPL, MPL) — copyleft applies to the modified files or library, not necessarily your whole application.

If your goal is simply to use a FOSS app, the license rarely restricts you. It matters when you fork it, bundle it into your own product, or run a modified version as a service.

Why people choose FOSS apps

The benefits are concrete rather than ideological:

• Verifiability — anyone can read the code or watch the build, so claims like "no telemetry" can be checked instead of trusted.
• No lock-in — your data and files stay in formats you control. Audion, for instance, scans local folders, reads tags, and keeps files local with "no accounts" and "no sign-in."
• Offline and privacy by default — a local-first player works without a connection and does not need to phone home.
• Longevity — if the original developer stops, the community can continue from the source.

How to check whether an app is really FOSS

1. Find the license. Look for a LICENSE file in the repository or a "License" link on the site. "Source available" or "we publish some code" is not the same as an OSI-approved license.
2. Find the source repository. A public repo with real commit history and issue activity is a good sign; a download-only page is not.
3. Check the build. Can you compile it from source, or at least see how releases are produced? Reproducible or documented builds make the "no tracking" claim auditable.
4. Read the pricing page carefully. Free core plus paid hosting or sync is normal and still FOSS. What you are checking is whether the code is free, not whether every service is.

Where FOSS falls short

• Support and pace — many projects are maintained by volunteers, so updates and bug fixes can be slow, and there may be no commercial support contract.
• Polish and edge cases — features you expect from paid software (advanced sync, mobile parity, integrations) may lag or be community-contributed.
• Fragmentation — forks and plugin ecosystems can split effort, so a plugin you rely on may go unmaintained.
• Hidden costs elsewhere — "free" often means you supply the hardware, hosting, or time. Running a self-hosted server, for example, needs a machine and some setup even when the software costs nothing.

A quick decision guide

• Choose FOSS when you want to verify behavior, avoid accounts and tracking, keep files local, or be able to fork and extend the tool.
• Choose proprietary or freeware when you need guaranteed support, a polished mobile experience out of the box, or features only a funded team maintains.
• When in doubt, check the license and the repository first — that single step separates genuine FOSS from marketing language.