SpewIt™ User Manual

Requirements

SpewIt is a local ASP.NET Core MVC (.NET 10) application that launches platform-specific project-generation scripts. Requirements depend on which type of project you want to create.

Application Overview

SpewIt™ is an application and code generator developed by Zero-Training AI, Inc. It introduces a radically different approach to software creation: generating applications through executable scripts, mathematical specifications, and deterministic processes rather than relying on Large Language Models (LLMs).

Products such as Claude have demonstrated the enormous commercial value of software that can write code and create applications. SpewIt™ pursues a similar objective, but through a fundamentally different technological architecture.

Claude uses language-model inference to generate code. SpewIt™ uses defined generation procedures, and its advanced PRO technology is based on the mathematics of Zero-Training AI™. Rather than asking a language model to predict the next line of code, the Zero-Training AI™ approach derives permitted decisions and executable behavior from mathematical relationships, objectives, constraints, and expert-defined specifications.

SpewIt™ FREE Edition — 100% FREE

This application is the completely FREE edition of SpewIt™. It is NOT SpewIt™ PRO.

The FREE edition is a professional software-development tool that generates application structures and source code through reproducible scripts, defined templates, configuration procedures, and build operations. It does not require a remote LLM to invent the generated application.

Users select an application type, enter a project name, specify a destination, choose the available generation options, and click Create It. SpewIt™ then executes the appropriate procedures to construct the project.

What the FREE Edition Can Create

• ASP.NET Core MVC applications: Generate C# websites targeting .NET 10 with conventional MVC architecture.
• Electron.NET desktop applications: Generate C# MVC applications with an optional desktop host targeting Windows and macOS.
• Rust Windows applications: Generate Rust and Tauri v2 desktop projects with supported web-based frontends.
• Rust mobile applications: Generate shared Rust/Tauri project structures targeting Android and iOS.
• Frontend selection: Use supported HTML, JavaScript, Angular, React, or Ionic configurations where available for the selected generator.
• Customized application generation: Supply project names, directories, templates, media assets, themes, and supported application settings.
• Reproducible development: Repeat the same generation procedures without depending on unpredictable language-model responses.

Who Should Use SpewIt™?

SpewIt™ is designed for experienced programmers, especially developers who understand C# or Rust, and for theoretical physicists interested in computational systems, mathematical modeling, and equation-based artificial intelligence.

This is not intended to be another beginner-oriented, prompt-driven AI coding tool. SpewIt™ assumes that its users understand software architecture, source code, compilation, debugging, dependencies, and application development.

The advanced Zero-Training AI™ technology introduces an additional and particularly demanding level of expertise. Its mathematical foundations draw upon theoretical physics, variational principles, constrained optimization, dynamical systems, and multidimensional decision spaces.

Conventional AI programming experience alone is not sufficient preparation for the advanced PRO technology. Someone who primarily develops applications by writing prompts for ChatGPT, Claude, or other LLMs may have little experience with the mathematics required to construct and validate a Zero-Training AI™ Decision Space. Understanding neural networks, prompt engineering, or model APIs does not automatically provide an understanding of variational calculus, Lagrangian mechanics, constrained manifolds, or admissible decision trajectories.

The PRO system is therefore intended for technically qualified users willing to define and validate the mathematical structure of the applications they want to create.

SpewIt™ PRO — Software Generation Through Theoretical Physics

The advanced technology described below belongs to the PRO offering, not the FREE application documented in this manual.

Zero-Training AI™ is built around a different proposition from conventional generative AI: intelligent behavior does not necessarily have to be learned from billions of examples. For sufficiently well-specified problems, it can instead be derived from equations governing what a system is permitted, required, and optimized to do.

Its mathematical framework draws on principles such as the Principle of Least Action, Euler-Lagrange equations, Lagrange multipliers, constrained optimization, and multidimensional decision geometry.

The user specifies the mathematical and operational structure of the problem. This can include:

• Dimensions: The variables, states, conditions, and quantities that define the problem.
• Relationships: The mathematical dependencies and interactions among dimensions.
• Constraints: The absolute boundaries and conditions that generated behavior must respect.
• Objectives: The outcomes the application must optimize within the admissible solution space.
• Weights, events, and kernels: Additional expert-defined elements governing the structure and evaluation of the decision system.
• Time and recoverability: Temporal relationships and conditions governing which future actions remain permissible or recoverable.

The Decision Engine evaluates these specifications, rejects alternatives that violate hard constraints, and determines admissible actions according to the mathematical objectives.

In the PRO software-generation architecture described by Zero-Training AI, Inc., this formal decision structure can be translated into executable logic and specialized source code. The objective is to generate software whose operating behavior follows explicitly defined mathematical rules, rather than behavior inferred from examples of previously written programs.

Similar Destination. Radically Different Technology.

Claude and other LLM-based coding systems demonstrate that software can help create more software. But the underlying question is whether enormous language models are necessary for every class of application.

Zero-Training AI™ proposes another path: define the solution space, calculate permissible behavior, and generate the executable software.

This distinction is particularly important for applications in which rules, relationships, and constraints can be specified precisely, including business logic, financial decision systems, policy evaluation, compliance, scientific computation, industrial control, and specialized mathematical applications.

Unlike an LLM-based coding service, this architecture does not require a remote language model to generate each decision or line of specialized logic. Its deterministic core is designed for local execution, repeatability, and independent verification.

From Gigabytes to Kilobytes — The USB-Drive Advantage

One of the most important architectural differences is the size of the underlying intelligence.

Modern LLMs commonly depend on large model-weight files, substantial computing resources, and sometimes cloud infrastructure. By contrast, Zero-Training AI™ is designed around compact equations, specialized decision logic, and executable mathematical procedures rather than enormous neural-network weight collections.

The vision is software-generation intelligence compact enough to be distributed on an ordinary USB drive instead of requiring a massive pretrained language model.

The Decision Engine and generated decision logic can be exceptionally compact. Complete application installations may still need the appropriate operating-system components, language runtimes, compilers, and development dependencies.

This approach offers a fundamentally different potential economic model: no language-model inference charges for each generation step, no token-based billing inherent to the Decision Engine, and no requirement to transmit proprietary decision specifications to an external LLM service.

Why This Matters to Software Developers and Investors

The commercial significance of SpewIt™ is not simply that it can create a new C# or Rust project. The broader opportunity is the development of a software-generation architecture that does not depend on the same statistical models, training-data requirements, or per-token economics as conventional generative AI.

Claude illustrates the market demand for AI-assisted software creation. SpewIt™ and Zero-Training AI™ represent an alternative engineering strategy for pursuing that market.

Instead of scaling intelligence primarily by increasing model size and inference resources, the Zero-Training AI™ approach seeks to scale application capability through mathematical specifications, reusable decision procedures, and compact executable logic.

For the classes of software where requirements and constraints can be formally expressed, this creates the potential for highly reproducible, auditable, locally executed application generation with a substantially different infrastructure and cost structure.

Learn About SpewIt™ PRO and the Decision Engine

The FREE edition provides practical, script-based application generation. The advanced equation-based Decision Engine and the software-generation technology described in our published technical article are part of the separate PRO offering.

To understand the mathematical architecture and our approach to generating specialized software without LLMs, read:

SpewIt™ Writes Software WITHOUT Any LLMs — William SerGio

You can also explore the Zero-Training AI™ Decision Engine and its mathematical decision-modeling concepts:

Explore the Zero-Training AI™ Decision Engine

SpewIt™ PRO is separate from this FREE application. Programmers, theoretical physicists, research organizations, technology companies, and prospective investors interested in the advanced Decision Engine and its software-generation capabilities should contact Zero-Training AI, Inc. for information about PRO access and technical demonstrations.

SpewIt™ — Software That Creates Software.
Powered by Zero-Training AI™.
Derived from equations — not trained on data.

Quick Start — Create Your First App

1. Launch SpewIt on your computer.
2. Select Create App in the top navigation.
3. In Application Type, select Create-DotNet10-MVC, CreateRustProject-Windows, or CreateRustProject-Mobile.
4. Set any options that appear for that application family: Electron.NET, Home video scrolling, or the frontend framework.
5. Enter a valid Project Name, such as MyNewApp.
6. Enter an absolute Project Path, such as C:\AiProjects.
7. Click Create It once. The button changes to Creating... while the script runs.
8. Read the status and generator output. A successful run identifies the generated project's destination.
9. Open the generated directory in your development environment and perform the build/run checks for that project type.

Navigation and Themes

SpewIt uses a compact fixed navigation bar with the SpewIt logo on the left. The current host layout contains the following entries:

Light and dark mode

Light mode uses a light navigation background. Dark mode uses dark gray styling. The host saves the selection under the local preference spewit.theme. Generator option controls follow the application's current theme.

On smaller screens, use the navbar's menu button to expand or collapse the navigation links.

Create App Screen — Every Control

The Create App screen is built from Views/Create/Index.cshtml and three option partials. The fields are:

The form submits using AJAX, without a full page refresh. Invalid entries are rejected before generator execution, and the service also validates its request server-side.

Application Types

Creating an ASP.NET Core MVC (.NET 10) Application

Select Create-DotNet10-MVC to generate a conventional ASP.NET Core MVC solution using C#, controllers, and Razor views. This generator does not create a Razor Pages application.

1. Select Create-DotNet10-MVC.
2. Decide whether you also want an Electron.NET desktop host.
3. Independently decide whether Home video scrolling should be enabled.
4. Enter the project name and absolute destination path.
5. Click Create It and review the generator output.

What the generator installs

• A new .NET 10 MVC project generated by dotnet new mvc.
• The dedicated layout template in Scripts/Create-DotNet10-MVC/_Layout.cshtml, copied into the generated app's Views/Shared/_Layout.cshtml.
• The current SpewIt Home page, copied into Views/Home/Index.cshtml with the SpewIt-specific nonce dependency removed for the new app.
• The generated app's Articles controller, view, and corresponding navbar entry.
• Custom site assets from the generator's www directory, copied to the new application's wwwroot.
• Local Bootstrap 5.3.8 distribution files, NuGet restore, and a .NET build attempt.

Generated C# navigation

Generated MVC applications use the dedicated layout, not SpewIt's own host layout. Their navbar contains SpewIt branding, Home, the Articles dropdown, the light/dark theme control, and YouTube. It does not copy the host's Create App or Add AI menu items.

Electron.NET — Windows and macOS Desktop Applications

When creating a .NET 10 MVC application, check Add Electron.NET desktop application to add Electron.NET as a desktop host. This option is not available for Rust projects.

Both Windows and macOS are always included as targets. SpewIt does not provide a Windows-only versus Mac-only checkbox for Electron. The generated project can target both, but final installation packages must be built on the relevant operating system with its required tools.

The generator adds the ElectronNET.API package, installs the local ElectronNET.CLI tool, initializes the Electron configuration, and produces an Electron-README.txt with further instructions.

cd C:\AiProjects\MyNewApp
dotnet tool run electronize --allow-roll-forward start

This example assumes a Windows project named MyNewApp. On macOS, use the corresponding macOS project path and terminal.

Home Video and the Independent Scrolling Option

SpewIt's Home page features a full-window video cover, a small Click to Watch Video button, and a video that plays when requested. The video area is sized relative to the visible window between the navbar and footer.

Generated MVC applications: two behaviors

The scrolling option changes the newly generated MVC application's layout by using the spewit-video-scroll class. It does not alter SpewIt's own Home page.

SpewIt itself keeps its Home video locked. This is separate from the selection made for a generated application. The checkbox has no effect on Rust Windows or Rust Mobile projects.

The www Folder — Images, Videos, and Other Assets

The MVC generator uses Scripts/Create-DotNet10-MVC/www as the source of static assets for newly created C# projects. It copies the folder's contents into each generated application's wwwroot, preserving the names and any nested directory structure.

In the current generator, the supplied www directory replaces the default MVC template's wwwroot, with a safeguard to restore its default jQuery distribution if the replacement does not contain one. Bootstrap is then installed locally.

Required Home media paths

Scripts/Create-DotNet10-MVC/www/
  videos/
    cover.png
    yourvideo.mp4
  img/
    as_seen_on_tv.png

The C# generator checks that these three media files exist at the expected paths inside the new wwwroot. A missing required file stops generation with a reported error.

Newly generated MVC apps also depend on branding assets used by their navbar, including the light and dark SpewIt logos and YouTube image. Keep those assets in the script's expected locations.

Creating a Rust Windows Desktop Application

Select CreateRustProject-Windows to create a Windows desktop application based on Rust and Tauri v2. The Rust generator is designed to run on Windows; the current project service rejects an attempt to use this specific generator from macOS.

Choose the frontend

• No UI — Tauri + HTML/CSS/JavaScript: generates a usable desktop interface built from plain web technologies. Here, “No UI” means no Angular or React framework; it does not mean a console-only or headless application.
• Angular Frontend: generates an Angular frontend hosted inside the Rust/Tauri desktop app.
• React Frontend: generates a React frontend hosted inside the Rust/Tauri desktop app.

The starter contains a frontend and a Rust backend. The plain-HTML variant provides Home and About pages and a sample Call Rust button to test communication with the native backend.

The generated project's spewit.project.json records its selected UI framework and Windows target.

Creating a Rust Mobile App — Android and iPhone

Select CreateRustProject-Mobile. SpewIt prepares one shared Rust/Tauri v2 project targeting Android and iOS, not two unrelated codebases.

Mobile interface choices

• No UI: plain HTML, CSS, and JavaScript in a Tauri mobile host.
• Angular: Angular frontend with Rust and Tauri v2.
• React: React frontend with Rust and Tauri v2.
• Ionic: an Ionic UI built on Angular or React, combined with Rust and Tauri v2.

The Ionic Framework selector becomes available only when you choose Ionic. Select Ionic Angular or Ionic React. This template uses Tauri as the native host; it is not a Capacitor-generated application.

What the generator verifies

It prepares the shared source, installs the frontend packages, initializes a Tauri project, and runs a frontend build. Where the required native toolchain is available, it attempts native-project initialization.

Platform-specific steps after generation

Android: install Android Studio, the Android SDK and NDK, Java/JDK, and the necessary Rust targets. When required, initialize with npm run tauri -- android init, then use android dev or android build.

iOS: use a Mac with Xcode, CocoaPods, and iOS Rust targets. Initialize with npm run tauri -- ios init when needed, then run or build the iOS target. Windows cannot produce a complete native iOS build on its own.

Understanding the User Interface Choices

Only options applicable to the currently selected application type are submitted to the generator. Switching between project families updates the displayed controls.

Project Names, Destination Paths, and Existing Files

Project Name rules

• Use 1–64 characters.
• Begin with a letter or underscore.
• Use letters, digits, underscores, and hyphens after the first character.
• Avoid Windows-reserved names such as CON, PRN, and NUL.

Project Path rules

Use a full absolute directory path, not a relative folder name. Windows examples include C:\AiProjects and F:\RustProj\MyNewApp. On macOS, use paths such as /Users/you/Projects.

If the final directory segment already matches the project name, SpewIt uses that directory. Otherwise, it appends the project name to the provided parent directory.

What Happens When You Click Create It?

1. SpewIt validates the required fields and compatible generator options.
2. The local Create controller checks that project generation is being requested from the same computer, not a remote machine.
3. The project service finds the matching generation script under Scripts.
4. On Windows it runs a PowerShell .ps1 script. On macOS it runs the corresponding Bash .sh script, where supported.
5. The script checks prerequisites, validates the destination, creates the project files, installs dependencies as required, and performs configured builds.
6. SpewIt captures standard output and errors and displays the result in the Create App screen.

The service imposes a 15-minute limit on one generator invocation and reports cancellation or timeout. The Create button is disabled during a run to discourage duplicate submissions.

SpewIt does not silently turn a failed generation into success. A nonzero script exit code is returned as a failure. Generator messages should be reviewed to identify the unsuccessful step.

Understanding Results and Generated Files

The results panel on Create App uses a status line followed by a scrollable monospaced output area.

Typical project files

MVC: Controllers, Models, Views, wwwroot, a .csproj file, optional Electron configuration, and generated Home/Articles views.

Rust Windows: a Rust/Tauri desktop host, frontend files, package definitions, and spewit.project.json.

Rust Mobile: frontend source, Rust/Tauri mobile source, package definitions, README.md, and spewit.project.json with native target initialization status.

The generator may truncate very long console output in the result panel. The detailed destination path and the last reported failing step are the most useful details to preserve.

Home, Articles, and Add AI

Home

SpewIt's current Home view contains a cover image, an MP4 video, a very small Click to Watch Video button, branding graphics, and an additional content section. The Home page is intentionally locked to the viewport in the SpewIt host.

Articles

The Articles dropdown opens an informational page describing SpewIt, deterministic software generation, and the Zero-Training AI approach. It is content for reading, not another project-generation form.

Add AI

The Add AI navigation route exists in the current source, but its view is presently a placeholder. The code reviewed for this manual does not contain a working Add AI configuration wizard, model editor, or deploy button. Those functions should not be treated as operational until implemented and tested.

What Is Zero-Training AI™?

Zero-Training AI™ is the deterministic decision architecture developed by Zero-Training AI, Inc. Its conceptual model is built around expert-defined dimensions, relationships, constraints, and objectives, rather than learning decision rules from a training-data corpus.

A problem may be expressed within an N-dimensional Decision Space™. Candidate actions are evaluated against the allowed constraints and objectives to identify an admissible action. Depending on the configured problem, this can involve geometric, variational, and constrained-optimization methods.

Preferred action = minimize(objective cost)
                   subject to approved constraints

SpewIt's project-generation workflow reflects the deterministic, inspectable-script philosophy: specified inputs are routed to defined generators, and those generators create source and project structures using explicit steps. It does not ask an LLM to fabricate an answer or charge a per-prompt inference fee.

Why SpewIt Uses Scripts

Project generators are stored in well-defined local directories. This approach makes each project recipe inspectable, versionable, repeatable, and straightforward to test.

SpewIt/
  Scripts/
    Create-DotNet10-MVC/
      Create-DotNet10-MVC.ps1
      Create-DotNet10-MVC.sh
      _Layout.cshtml
      www/ ...
    CreateRustProject-Windows/
      CreateRustProject-Windows.ps1
    CreateRustProject-Mobile/
      CreateRustProject-Mobile.ps1
      CreateRustProject-Mobile.sh
      GenerateRustMobileUi.mjs

Benefits of the script-based design

• Reproducibility: project creation follows explicit commands rather than unpredictable generated text.
• Auditability: a developer can inspect the exact files, templates, and commands used.
• Customization: the template folder and scripts can be updated without redesigning the Create App screen.
• Separation: the SpewIt host's own pages are independent of the templates copied into generated apps.
• Testing: each generator family and option combination can be tested against known outputs.

When customizing scripts, use source control and retest every relevant option combination. A script change affects future generated projects; it does not automatically update old ones.

Verification and Testing Checklist

After each generation, verify the result rather than relying only on a success message.

1. Confirm the destination is the directory you requested and includes the generated source.
2. For MVC, confirm the project targets .NET 10, contains the expected Controllers and Views, and builds.
3. For MVC, open Home and verify the cover, video, navbar, light/dark theme, Articles route, and YouTube image.
4. Generate and test both states of the Home scrolling checkbox. Verify that the Electron.NET choice does not change that behavior.
5. For Electron, check the local Electron configuration and test desktop startup on the target operating system.
6. For Rust Windows, verify that the selected UI renders in Tauri and its JavaScript-to-Rust test call works.
7. For Rust Mobile, check the frontend build and then separately initialize, compile, and test the Android and iOS native projects.
8. Check spewit.project.json or project READMEs for generated configuration and platform status where applicable.

Troubleshooting

Useful information when reporting a problem

Provide the exact Application Type, UI choice, Electron and scrolling selections, operating system, toolchain versions, the last output lines, and whether the destination already contained files. Avoid including passwords, access tokens, or other secrets in copied logs.

Local Use, Access, and Security

The reviewed SpewIt project does not require a user account or sign-in to access its Create App form. Its Create controller restricts the actual file-generating action to local-loopback requests.

Project generation creates directories, executes scripts, and may install packages. Use SpewIt on a computer you control, inspect customized scripts before running them, and review the dependencies installed into newly created applications.

The generated source is yours to review, edit, build, and test. Creating an application does not, by itself, validate the security, licensing, accessibility, or regulatory compliance of the finished software.

Current Release Scope and Important Distinctions

This manual describes the latest SpewIt project source supplied in the October 31, 2026 development work. Future releases may add more generator types and implemented controls.

Legal Notice

SpewIt™ and Zero-Training AI™ are products and technology of Zero-Training AI, Inc. Product names, source templates, scripts, trademarks, and related technical material may be protected by applicable intellectual-property rights.

SpewIt is a software-development tool. Source generation and successful compilation do not guarantee that an application is suitable for production, secure against all attacks, or compliant with every applicable law, contract, or technical standard. Developers are responsible for examining generated code and independently testing their deployments.

Third-party technologies such as ASP.NET Core, .NET, Electron.NET, Rust, Tauri, Angular, React, Ionic, Bootstrap, and associated packages remain subject to their respective licensing terms.

© 2026 Zero-Training AI, Inc. All rights reserved.