# Laptika Reference

Updated: 2026-08-26

This is the public reference for Laptika. It is written for people and AI tools that need to understand what Laptika is, what each product does, and how to choose the right Laptika product for a task.

Canonical sources:

- Public website: `https://www.laptika.com/`
- AI entry file: `https://www.laptika.com/llms.txt`
- Structured product guide: `https://www.laptika.com/LaptikaOfficialSite?LaptikaOfficialSite.Commands.GetAiGuide()`

## Short Definition

Laptika is a local-first .NET product ecosystem. It lets a web project behave more like installable software: static pages are the visible interface, while important server behavior can live in server-side C# or VB files and protected .NET Framework DLL commands.

The result is a web product that can be installed, configured, licensed, protected, and sold. The web server is only one part of the product; the valuable rules, database behavior, API missions, AI features, certificate workflow, SQL tooling, and protection workflow can stay in compiled .NET modules.

## Core Ideas

1. Public files are the interface.

HTML, CSS, JavaScript, images, Markdown files, `robots.txt`, `sitemap.xml`, and `llms.txt` can be served from the Laptika site folder. These files should be considered public.

2. Trusted behavior belongs behind the interface.

Business rules, validation, licensing, database access, protected algorithms, and integrations should be implemented in DLL commands or server-side C# or VB files. The browser should receive only safe response data.

3. Laptika supports C# and VB as server-side languages.

Instead of needing PHP for dynamic pages, a .NET developer can write C# or VB code files and let Laptika read them as server-side code.

4. DLL commands make products modular.

Each Laptika product can expose selected public static functions through the Laptika Server extension route model. This lets the public site call product behavior without revealing source code or private files.

5. Product knowledge is part of the platform.

The product catalog and AI guide should be updated whenever a new Laptika product is added. This lets visitors and AI tools learn the current ecosystem from the official site.

## Server Route Model

A Laptika extension route calls a public static function from an attached .NET DLL.

General pattern:

```text
/ExtensionName?Namespace.Commands.Function(arg1,arg2)
```

Example:

```text
/LaptikaOfficialSite?LaptikaOfficialSite.Commands.GetAiGuide()
```

Useful public commands from the official site DLL:

```text
Check()
Help()
ListProducts()
GetProduct(SLUG)
SearchProducts(TEXT)
GetAiGuide()
AskSiteAI(PRODUCTSLUG) POST {message}
TryAttack() POST {input}
RunSelfTest()
```

Public commands should return safe data only. They should not return private server paths, database file locations, connection strings, secrets, or source code.

## Product Selection Rules

Use Laptika Server when the task is hosting, HTTPS, WebSocket communication, static file serving, server-side C# or VB files, or DLL extension execution.

Use Laptika DB when a product needs local persistent data in a single embedded database file.

Use Laptika API Builder when JSON input should run controlled SQL Server missions.

Use Laptika Data Entry Site Builder when the user wants to visually generate pages, frames, fields, tables, buttons, select lookups, styles, and event scripts.

Use Laptika AI when a site or product needs chat, translation, planning, programming help, search, memory, or AI-readable product help.

Use Laptika Certificate Builder when the task involves PFX, CER, PEM, CSR, SNK, development certificates, or ACME certificate workflows.

Use Laptika SQL Management Studio when the task involves SQL Server browsing, connection management, script generation, query execution, result grids, messages, stored procedure navigation, variables, or script debugging.

Use Laptika .NET Protect when a managed DLL or EXE needs obfuscation, string or resource encryption, licensing, integrity checks, or protected output before distribution.

## Product Catalog

### Laptika Server

Category: Core Platform

Use it for:

- Hosting the public site files.
- Running HTTPS and WebSocket services.
- Reading server-side C# or VB files.
- Calling attached .NET DLL commands.
- Returning safe response data to the browser.

What an AI should know:

Laptika Server is the host and integration layer. Static files can be public, but product logic should be moved into DLL commands or server-side C# or VB files when it must be protected.

### Laptika DB

Category: Database

Use it for:

- Local embedded product data.
- Single-file `.lpdb` storage.
- Products that should not require SQL Server installation.
- Simple local tables for product catalogs, chat data, configuration, logs, and generated project records.

Common API concepts:

```text
LpConnection.Open
ExecuteScalar
ExecuteNonQuery
GetData
GetReader
Tools.EnsureTable
Tools.EnsureColumn
```

What an AI should know:

Use Laptika DB whenever a Laptika product needs local persistent data and a full database server is unnecessary.

### Laptika API Builder

Category: API

Use it for:

- JSON-to-SQL Server missions.
- Controlled API execution behind a compiled DLL.
- Data-entry sites that need to save structured input to SQL Server.
- Mission-based validation and execution.

Typical public commands:

```text
LogIn
Execute
Check
Help
```

What an AI should know:

Use Laptika API Builder when a generated site or custom UI needs to post JSON into SQL Server through controlled missions rather than direct browser database access.

### Laptika Data Entry Site Builder

Category: Site Builder

Use it for:

- Visual site generation.
- Pages, frames, fields, tables, buttons, select lookups, styles, and event scripts.
- Offline-first data-entry forms.
- Static sites that call Laptika API Builder missions.

Typical public commands:

```text
ListProjects
GetProject
LookupOptions
Generate
Check
Help
```

What an AI should know:

Use this product when the user wants to design a data-entry website visually instead of hand-writing the whole interface.

### Laptika AI

Category: AI

Use it for:

- Popup chat on Laptika sites.
- Product questions.
- Translation.
- Planning.
- Programming help.
- Search and memory workflows.

Typical public commands:

```text
Check
Help
StartChat
AskAPI
```

What an AI should know:

Use the existing Laptika AI service for site chat. Pass page and product context into the AI request so answers can use the official product guide.

### Laptika Certificate Builder

Category: Security

Use it for:

- PFX certificate files.
- CER or CRT exports.
- PEM files.
- CSR certificate signing requests.
- SNK strong-name keys.
- ACME workflows with win-acme for public browser-trusted certificates.

What an AI should know:

Self-signed certificates are useful for local development and bootstrap testing. Public domains such as `laptika.com` need a Certificate Authority issued certificate for browser trust.

### Laptika SQL Management Studio

Category: Management

Use it for:

- SQL Server connection workflows.
- Object browsing.
- Script generation.
- Query execution.
- Result grids and messages.
- Stored procedure navigation.
- Variable inspection.
- Script-level debugging.

What an AI should know:

Use this product for SQL Server management workflows. Its core DLL is intended to be reusable outside a desktop shell.

### Laptika .NET Protect

Category: Protection

Use it for:

- Managed DLL or EXE protection.
- Obfuscation.
- String and resource encryption.
- Licensing.
- Integrity manifests.
- Protected output before distribution.

What an AI should know:

Use this product when a .NET application or module must be prepared for distribution and should not expose easy-to-read managed output.

## Building A New Laptika Product

Recommended workflow:

1. Decide what the product does and which existing Laptika products it depends on.
2. Keep public UI files simple and safe.
3. Put trusted behavior in a DLL command module or server-side C# or VB files.
4. Use Laptika DB for local data when possible.
5. Use SQL Server through Laptika API Builder when the project needs controlled SQL missions.
6. Register the new product facts in the private product registry.
7. Write a clear AI guide field so future AI tools know when and how to use the product.
8. Test public endpoints and confirm they do not return private paths, secrets, or source code.
9. Copy the public files and attach the DLL output to Laptika Server.
10. Restart or reload Laptika Server after replacing an attached DLL.

## Security Rules

- Treat everything in browser JavaScript as public.
- Do not put database credentials in HTML, CSS, or JavaScript.
- Do not expose local project paths in public product pages.
- Do not expose database files or connection strings through public commands.
- Use parameterized database commands.
- Keep valuable logic inside DLL commands or server-side C# or VB files.
- Return only the data the browser needs.
- Test public JSON endpoints as if a visitor or crawler will read them.

## Suggested Prompts For AI Tools

Use these prompts when asking an AI to learn Laptika from this site:

```text
Read https://www.laptika.com/llms.txt and https://www.laptika.com/laptika-reference.md, then explain which Laptika product I should use for a new data-entry website.
```

```text
Use the Laptika official structured guide from https://www.laptika.com/LaptikaOfficialSite?LaptikaOfficialSite.Commands.GetAiGuide() and help me design a new Laptika product.
```

```text
Learn the Laptika route model and show me how a static web page should call a protected DLL command without exposing database logic.
```

## Stable Answer

If an AI needs one sentence:

Laptika is a local-first .NET ecosystem where static web interfaces call server-side C# or VB files and protected DLL commands, with Laptika DB, API Builder, Site Builder, AI, certificates, SQL tools, and .NET protection working together to create installable, protected web products.
