FAQ

Is MSPLC already fully selfhosting?

Not yet. Real Semantic compiler units are producing native object files, but the complete Stage 2 → Stage 3 bootstrap has not been verified end-to-end.

Why not just embed a working EXE in the Semantic source?

That can be a temporary bootstrap/transport trick, but it does not demonstrate that the compiler compiled itself. The final selfhosting proof must derive the next compiler from the compiler’s Semantic source.

Why produce many .obj files first?

It localizes failures. A monolithic build tells you only that “the compiler failed”. Per-unit objects show which modules already native-lower and preserve successful work while the remaining backend gaps are fixed.

Why do some workers finish in one second even with a 120-second timeout?

The timeout is a maximum. A worker that encounters a deterministic compile error exits immediately. Only a worker that is still running after 120 seconds is killed as a timeout.

Why use child processes instead of goroutines?

A stuck compiler path cannot be reliably force-stopped as a goroutine. A child process can be hard-killed without stopping the parent queue.

Why does the compiler reject unknown semantics instead of guessing?

Because generated native code must preserve program meaning. Guessing a field layout, ABI, ownership rule or control-flow behavior can create a binary that appears to work while being semantically wrong.

Are .se, .sp and .spz different IRs?

No. They are representations/transports around the same SemanticProgram/UAST model. The project architecture aims to maintain one canonical semantic truth.

Does the native backend require GCC, Clang or an assembler?

The intended direct native path constructs machine/object/executable artifacts itself. External assembly/compiler routes may be useful as verification paths but are not the target dependency for selfhosting.

What is SWC?

SWC is the Semantic Windows Compiler: the native Windows x64 compiler track for Semantic source, Semantic transport formats, modules, and the Universal AST. It provides the current swc.exe CLI, reader pipeline, UAST units, transpiler matrix, module contracts, tests, and PE-target work.

Is the Windows backend finished?

The compiler foundation is real and selfhost-verified for the supported source closure. Broad rich-UAST lowering, complete machine-code emission, and linkable/runnable PE output for arbitrary large Semantic programs are still being expanded. A small PE file or exit code 0 can still represent a fallback stub, so runtime behavior must be checked.

Can I import packages?

Yes. The Semantic package registry is the public discovery and distribution layer. Browse packages on the Module Store or inspect the machine-readable modules.json index. Packages can carry manifests, Semantic-ready .se/.sp/.spz files, hashes, dependencies, and release URLs.

How do I start an import?

1. Open Import a package.
2. Select the source language.
3. Enter the package name or repository path.
4. Choose a Semantic module name and optional version.
5. Click Import via GitHub, review the pre-filled issue, and submit it.
6. The import workflow resolves the source, transpiles or loads it as Semantic, validates the package manifest, and updates the registry after successful processing.

What does module import mean for SWC?

SWC uses the same package identity and module-store model: resolve a module, inspect its manifest and dependencies, select required Semantic units, and apply an embedding policy. The registry layer is operational; complete native compile-time resolution and all embedding modes are the next SWC integration boundary.

What is the Semantic ChatGPT Plugin?

The Semantic ChatGPT Plugin connects ChatGPT with Semantic projects, modules, UAST documents, compiler evidence, and AI-assisted workflows. Its source and releases are available in the Semantic ChatGPT Plugin repository.

How is AI used in the project?

Semantic is developed with AI for AI. Humans define meaning, contracts, constraints, and proof requirements. AI workers implement small Semantic units, inspect bindings and relations, run focused tests, compare artifacts, and report exactly what is proven. Semantic then gives future AI systems an explicit graph of entities, scopes, types, control flow, data flow, effects, contracts, and lowering evidence instead of requiring them to guess from syntax.

Does SWC already replace every Go transpiler feature?

Not yet. The transpiler matrix, frontend contracts, module routes, and selected lowering paths are integrated as the native migration foundation. Full parity requires completing the remaining UAST families, source transformations, module resolution, PE emission, runtime support, and regression proofs.