GET STARTED

Get started with Alchemist AI

Overview:

Alchemist AI is a no-code development platform (NCDP) that enables users to create software applications with just a simple description. By eliminating the need for coding expertise, our AI enables anyone from beginners to professionals to generate bespoke applications on the fly - ranging from simple utilities to games.

Our system involves Natural Language Processing (NLP), Code Generation, Web Framework Integration, and access to a Limited OS API. The Large Language Model (LLM) plays a pivotal role throughout the process, handling everything from parsing user input to generating executable code.

Key Technical Components:

  1. User Input Processing (Natural Language Understanding)

  2. Application Logic Generation

  3. Code Generation and Deployment

  4. Execution Environment (Web Rendering and Sandbox)

  5. OS API Integration

1. User Input Processing: Natural Language Understanding

The first step is receiving a natural language description of the desired application. The input can range from simple commands like, "Build me a timer," to more complex instructions, such as "Create a game where I catch falling stars and gain points for each one caught."

How It Works:

  • Natural Language Processing (NLP): The system uses an LLM to parse and understand the user's input.

  • The model is trained to extract intent (what the app is supposed to do), attributes (specific features, such as time tracking, game mechanics, etc.), and constraints (design preferences, platform considerations).

    Example:

    • User Input: "Create a game where I catch falling stars and gain points for each one caught."

    • LLM’s interpretation:

      • Intent: Game

      • Features: Falling objects, scoring points.

      • Actions: Catch, increase score.

      • UI/UX: Simple interface with moving objects and score display.

  • Entity Recognition: The LLM also identifies key terms, like "falling objects," "score," and "game," and interprets them into actionable design components.

2. Application Logic Generation

Once the input is parsed, Alchemist AI proceeds to generate the application logic. This is where the LLM takes over to build the back-end logic for the app. The model constructs relevant algorithms, event handling, and UI behavior based on the recognized intent.

How It Works:

  • The system determines the type of application (game, utility, tool, etc.) based on the input.

  • It selects or generates a template based on the app type (for example, a template for a falling objects game, or a timer app).

  • For games, the system may generate code for:

    • Object Movement: Physics-based calculations (e.g., gravity, speed) to simulate falling objects.

    • User Interaction: Detecting key presses or mouse movements for dodging actions.

    • Scoring Logic: Incrementing the score when the player avoids objects.

  • For utilities like a timer, the LLM might:

    • Define Timers: Use setInterval or other mechanisms to update the time.

    • Create Event Handlers: Buttons for starting, pausing, or resetting the timer.

    • Styling: Generate CSS for a minimalist, clock-like design.

  • The LLM will also incorporate logic for handling user input dynamically, like reacting to mouse clicks, keyboard presses, or form submissions.

3. Code Generation and Deployment

The heart of Alchemist AI lies in its ability to convert natural language instructions into executable code. This process involves generating HTML, CSS, and JavaScript, which are the core components of modern web-based applications.

How It Works:

  • HTML Generation: Alchemist AI generates the static structure of the app using HTML. This includes:

    • Layout: Setting up containers for UI elements (buttons, scoreboards, etc.).

    • Interactive Elements: Generating HTML tags like buttons (<button>), input fields (<input>), and score displays (<div> or <span>).

  • CSS Generation: The system generates the necessary styling for the app based on the input. For example:

    • Themes: Alchemist AI would generate appropriate CSS from user's input.

  • JavaScript Logic: The LLM generates the necessary JavaScript to make the app interactive. This could include:

    • Game Mechanics: For example, randomizing the fall speed of objects or detecting collisions with the player’s character.

    • Timers/Countdowns: For applications like countdown timers or stopwatches.

    • State Management: Handling the app’s state (e.g., score, timer values, user input).

Example Code Snippet for Falling Objects Game:

<!DOCTYPE html>
<html lang="en">
<head>
  <meta charset="UTF-8">
  <meta name="viewport" content="width=device-width, initial-scale=1.0">
  <title>Falling Objects Game</title>
  <style>
    body { background-color: #222; color: white; font-family: Arial, sans-serif; }
    .falling-object { position: absolute; background: red; width: 30px; height: 30px; }
    #score { position: fixed; top: 10px; left: 10px; font-size: 20px; }
  </style>
</head>
<body>
  <div id="score">Score: 0</div>
  <script>
    let score = 0;
    const fallingObjects = [];
    function createFallingObject() {
      const obj = document.createElement('div');
      obj.className = 'falling-object';
      obj.style.left = `${Math.random() * window.innerWidth}px`;
      document.body.appendChild(obj);
      fallingObjects.push(obj);
    }
    function updateGame() {
      fallingObjects.forEach(obj => {
        let top = parseInt(obj.style.top || 0);
        if (top < window.innerHeight) {
          obj.style.top = top + 5 + 'px';
        } else {
          obj.remove();
          score++;
          document.getElementById('score').innerText = 'Score: ' + score;
        }
      });
    }
    setInterval(createFallingObject, 1000);
    setInterval(updateGame, 50);
  </script>
</body>
</html>

4. Execution Environment (Web Rendering and Sandbox)

Once the application is generated, it is rendered in an iframe or a similar web-based environment where the user can interact with the app. This ensures that the generated app can be viewed and tested directly in a browser.

How It Works:

  • Secure Sandboxing: The generated code runs in a sandboxed environment to prevent security risks, such as unauthorized file system access or malicious behavior.

    • Alchemist AI ensures that any app’s code can only interact with the environment that is explicitly allowed by the platform’s Limited OS API.

    • The sandboxed environment provides a safe, isolated execution space, ensuring that even if the app has bugs or malicious code, it does not affect the user’s device.

  • Real-Time Feedback Loop: Users can interact with the generated app (e.g., play the game, use the timer) and give feedback. This allows the AI to quickly adapt and re-generate the application with adjustments or fixes based on that feedback.

5. OS API Integration (Limited Access)

For applications that require interaction with the local environment (e.g., saving files, accessing system settings, or working with device hardware), the platform can integrate with a Limited OS API. This API would provide access to the file system, registry, and other OS-specific features in a secure and controlled manner.

How It Works:

  • File System Access: Users can save files or load configuration settings within predefined directories, with the system ensuring that apps cannot access arbitrary locations on the user’s machine.

  • Registry Access (for Windows): The AI might be able to modify certain registry settings (e.g., saving application preferences) if the user requests such functionality.

Learn how to FORGE!

PreviousINTRODUCTIONNextAI LABORATORY

Last updated