mamedev.org

MAME is distributed under the GNU General Public License, version 2 (GPL-2.0) as a whole project, because it contains code released under multiple GPL-compatible licenses. At the same time, more than 90% of its files — including core files — are under the BSD-3-Clause License, and the project encourages new contributors to distribute their files under that license. Separately from the code license, "MAME" is a registered trademark of Gregory Ember, and permission is required to use the name, logo, or wordmark.

The two licenses, side by side

The MAME codebase is not covered by a single uniform license. It is a mix, and the project describes it at two levels:

So the answer depends on what you are asking about: the project as a distributed whole is GPL-2.0, while most individual files — including core ones — are BSD-3-Clause.

Why the project is GPL-2.0 overall

MAME's own description explains the mechanism: the project "as a whole is distributed under the terms of the GNU General Public License, 2 (GPL-2.0), since it contains code made available under multiple GPL-compatible licenses." In other words, the whole is governed by GPL-2.0 because it combines components that are GPL-compatible, even though a large share of the individual files use the more permissive BSD-3-Clause.

This distinction matters if you are reusing code. If you take an individual file that carries BSD-3-Clause terms, those terms apply to that file. If you take the project as a whole, the GPL-2.0 terms for the combined distribution apply.

Guidance for new contributors

The site is explicit about what it prefers for new code: "A great majority of files (over 90% including core files) are under the BSD-3-Clause License and we would encourage new contributors to distribute files under this license." If you are planning to submit code to MAME, BSD-3-Clause is the recommended choice.

The trademark is separate from the code license

The code license does not grant rights to the MAME name or branding. The site states that "MAME is a registered trademark of Gregory Ember, and permission is required to use the 'MAME' name, logo or wordmark." This applies regardless of which code license covers the files you are working with — a permissive code license does not carry trademark permission with it.

If your goal is to redistribute MAME, fork it, or build on its source, check the license on the specific files you use and treat the name and logo as a separate permission you must obtain. If your goal is to contribute, BSD-3-Clause is the license the project asks you to use.

A postal code API returns structured location data for a given ZIP Code or Canadian postal code. A typical response includes the code itself, city, state or province, county, latitude/longitude, and — where available — ZIP+4 detail. More complete services add time zone, area codes, boundary geometry, and demographic fields. You send a code (or an address), and the API sends back a machine-readable record you can store, validate, or display.

This article explains what those responses contain, how requests are usually shaped, and where postal code data fits into real applications.

First, clear up the word "code"

The keyword "code" is overloaded, and that causes real confusion for developers:

• Postal code — the ZIP Code (U.S.) or postal code (Canada) that identifies a delivery area.
• API key — the credential you use to authenticate your requests. It is not postal data.
• Source code — the program you write to call the API.

When someone searches for "postal code API code," they usually want example request/response code for a postal code service. The rest of this article treats it that way.

What a postal code API actually returns

Response fields vary by provider and endpoint, but the core set is fairly consistent. A single-code lookup commonly returns:

Richer datasets add 90+ fields: boundaries, population, income, elevation, and more. You rarely need all of them — request only what your application uses.

A representative JSON response

{
  "postal_code": "90210",
  "city": "Beverly Hills",
  "state": "CA",
  "county": "Los Angeles",
  "latitude": 34.0901,
  "longitude": -118.4065,
  "timezone": "America/Los_Angeles",
  "area_codes": ["310", "424"]
}

XML responses carry the same information in tag form. Choose based on what your stack parses most easily; JSON is the common default.

Common request patterns

Most postal code APIs support four patterns. Knowing which one you need prevents wasted calls.

1. Lookup by code

You have a code and want its details. This is the simplest and fastest call.

GET /lookup?code=90210

2. Reverse lookup by address

You have a street address and want to confirm or complete the code. This is the pattern behind checkout address validation.

GET /validate?street=...&city=...&state=...

3. Radius search

You have a center point and want all codes within a distance. Useful for store locators and delivery zones.

GET /radius?code=90210&miles=10

4. Batch validation

You have a file of addresses and want them cleaned in bulk. Batch endpoints trade latency for throughput and usually have their own limits.

Handling missing and ambiguous matches

Real data is messy. Plan for these cases:

• No match — the code doesn't exist or the address is malformed. Return a clear error rather than a silent empty object.
• Multiple matches — a city name may map to several codes, or a code may span several acceptable city names. Decide whether to pick the primary or return a list.
• Partial match — the street is valid but the ZIP+4 isn't. Fall back to the 5-digit code.
• Stale data — codes are added, retired, and reassigned. Refresh your dataset on a regular schedule.

A practical rule: validate at the point of entry, store the normalized result, and never re-derive it later from raw user input.

Practical use cases

• Checkout address validation — catch typos before shipping, reduce failed deliveries.
• Shipping zone lookup — map a code to a zone, carrier route, or rate table.
• Data enrichment — append county, coordinates, or demographics to existing records.
• Store and service locators — radius search to find nearby branches or coverage areas.
• Territory and tax logic — county and boundary data drive jurisdiction rules.

Licensing and data-source considerations

Postal code data originates with national authorities — USPS in the United States and Canada Post in Canada. Providers license and repackage it, which is why accuracy, update frequency, and field coverage differ between services. Before committing:

• Confirm the data source and how often it refreshes.
• Check whether ZIP+4 and boundary data are included or sold separately.
• Review usage limits and whether batch processing is allowed.
• Read the license terms for redistribution and storage.

Pricing and plan details change, so check the provider's current documentation rather than relying on secondhand figures.

Getting started

1. Decide which request pattern you need (lookup, reverse, radius, or batch).
2. Pick the fields you'll actually store.
3. Write a small test call and inspect the raw response.
4. Add error handling for no-match and ambiguous cases.
5. Cache results where the same codes repeat.

A postal code API is ultimately a translation layer: you give it a code or an address, and it gives back structured location facts. Understand the fields, match them to your use case, and handle the messy edges — that's most of the work.

MAME is a multi-purpose emulation framework whose stated purpose is to preserve decades of software history. According to the official MAMEdev.org site, it achieves this by documenting hardware and how it functions — and the source code itself serves as that documentation. The software being usable is, in the project's framing, primarily a way to validate the accuracy of the documentation: if you can run the software faithfully, you have evidence the hardware recreation is correct. This matters if you are trying to understand MAME as a preservation project rather than just as a way to play old games.

The core idea: documentation first, playability as proof

The official description is explicit about the relationship between emulation and documentation:

• MAME documents the hardware and how it functions.
• The source code to MAME serves as this documentation.
• The fact that the software is usable serves primarily to validate the accuracy of that documentation.

So when you run a game or system in MAME, you are not just consuming a product — you are exercising a claim about how the original hardware behaved. That is why accuracy, not convenience, is the project's central measure.

What MAME actually covers

MAME originally stood for Multiple Arcade Machine Emulator, focused on arcade video games. Over time it absorbed the sister project MESS (Multi Emulator Super System). As a result, MAME now documents a wide variety of mostly vintage systems, including:

• Arcade video games (its original focus)
• Computers
• Video game consoles
• Calculators

This is why "multi-purpose emulation framework" is a more accurate label than "arcade emulator" today.

How it differs from a typical emulator

The practical consequence: MAME's priorities can differ from what a casual user expects. Features and fixes are often driven by whether they improve the fidelity of the hardware documentation, not only by whether they make a game more convenient to play.

Licensing and naming, in brief

• The MAME project as a whole is distributed under the GNU General Public License, version 2 (GPL-2.0), since it contains code under multiple GPL-compatible licenses.
• Over 90% of files, including core files, are under the BSD-3-Clause License, and the project encourages new contributors to distribute files under that license.
• MAME is a registered trademark of Gregory Ember, and permission is required to use the "MAME" name, logo, or wordmark.

These points matter if you plan to redistribute MAME, reuse its code, or use its name in your own project.

Where to go next on the official site

MAMEdev.org organizes its resources into a few clear areas, which is useful if you want to go beyond the definition:

• Information — About, History, Legal, Logo, Contact
• Resources — Downloads (latest and previous releases), ROMs, Documentation, MAMEdev Wiki, Frequently Asked Questions, Emulated System Guides
• Community — Official Forums, GitHub discussions, IRC chat, and social channels
• Development — MAME on GitHub, Compiling MAME, Technical Specifications, Browse Source Code, Development Tools

If your goal is to understand the project's purpose, the "About" and "History" pages plus the documentation are the most direct sources. If your goal is to build or contribute, the development section is the entry point.

MAMEdev.org is the official website of the MAME Development Team and the home of The MAME Project. It is a development and documentation hub for MAME, a multi-purpose emulation framework whose stated purpose is to preserve decades of software history by documenting hardware and how it functions. It is not a ROM distribution site: the site centers on project information, downloads of MAME itself, documentation, and news.

Who runs it and what it is for

The site is maintained by the MAME Development Team. Its own description frames MAME as a preservation project first and an emulator second — the source code serves as documentation of the emulated hardware, and the fact that the software is usable mainly validates how accurately that hardware has been recreated.

Over time, MAME (originally "Multiple Arcade Machine Emulator") absorbed the sister project MESS (Multi Emulator Super System). As a result, it now documents a wide variety of mostly vintage computers, video game consoles, and calculators, in addition to the arcade video games it started with.

What you can find on the site

The navigation reflects a project hub rather than a download portal for game content:

The "ROMs" entry under Resources is a documentation-oriented page about ROMs and how MAME handles them, not a place to obtain copyrighted game data.

Licensing and trademark

• The MAME project as a whole is distributed under the GNU General Public License, version 2 (GPL-2.0), since it contains code under multiple GPL-compatible licenses.
• Over 90% of files, including core files, are under the BSD-3-Clause License, and the project encourages new contributors to distribute files under that license.
• "MAME" is a registered trademark of Gregory Ember. Permission is required to use the MAME name, logo, or wordmark.

Releases and news

The News section carries release announcements. For example, the MAME 0.289 announcement (dated 31 Jul 2026) describes a large update and notes several platform-level changes: Windows binary releases now include the SDL sound output and joystick input modules; the sdljoy joystick input module supports game controllers with up to 128 buttons; the Win32 debugger module handles dynamic UI scaling changes; and outputs were overhauled for performance and bug fixes, with a note that existing configurations may need updating.

When to use it

• Use MAMEdev.org if you want the official MAME binaries, source code, compilation instructions, or technical documentation.
• Use it to check licensing terms before redistributing or rebranding anything MAME-related.
• Do not expect it to supply ROMs or other copyrighted game data; it is a development and documentation site.

MAMEdev.org is the official site of the MAME development team, and it is the correct starting point for downloading MAME, reading the official documentation, and reaching the project's community and development resources. Use it when you want the current release rather than a mirror or third-party build, when you need the MAME documentation or wiki, or when you want to file issues, join discussions, or compile MAME yourself.

Downloading MAME

The site's Download section is split into two paths:

• Latest Release — the current version of MAME. The site's news feed shows MAME 0.289 dated 31 Jul 2026 as the most recent release at the time of that entry.
• Previous Releases — older versions, useful if you need to match a specific version for compatibility or testing.

The site also lists Supported Platforms, so check that section before downloading to confirm your operating system is covered by an official build.

Note from the 0.289 release notes: Windows binary releases now include the SDL sound output and joystick input modules, the sdljoy joystick input module supports controllers with up to 128 buttons, and outputs were overhauled — which may require updating your configuration after upgrading.

Documentation

Documentation is grouped under Resources:

Community

Official community entry points listed on the site:

• Official Forums
• MAMEdev Discussions on GitHub
• Chat on IRC
• MAME on Twitter, Bluesky, and Facebook

Development

If you want to work with the source rather than just run MAME:

• MAME on GitHub — the project repository
• Compiling MAME — build instructions
• Technical Specifications — hardware and implementation details
• Browse Source Code — read the code directly
• Development Tools — tooling used by the project

What MAME Is, and Why It Matters Here

MAME is a multi-purpose emulation framework whose purpose is to preserve decades of software history by documenting hardware and how it functions. The source code itself serves as that documentation, and the fact that the software is usable primarily validates the accuracy of that documentation. MAME originally stood for Multiple Arcade Machine Emulator, and it later absorbed the sister project MESS (Multi Emulator Super System), so it now documents a wide variety of mostly vintage computers, video game consoles, and calculators in addition to arcade video games.

Licensing

The MAME project as a whole is distributed under the GNU General Public License, version 2 (GPL-2.0), since it contains code under multiple GPL-compatible licenses. Over 90% of files, including core files, are under the BSD-3-Clause License, and new contributors are encouraged to distribute files under that license. MAME is a registered trademark of Gregory Ember, and permission is required to use the "MAME" name, logo, or wordmark.