Build PyTorch with Plovane
Stop guessing and start building. Plovane is a workspace that gives you exactly the help you need, from ready-to-run templates to a raw notebook, without ever hallucinating your code.
Overview
Prototyping usually feels like a mess—jumping between template repos, notebooks, and random snippets. Plovane puts everything in one place. Whether you want a guided start or full manual control, you work on the same project and the same canonical code.
Our core rule: no fabricated code. Plovane helps you move faster, but it never invents APIs. Every suggestion comes from a verified library, so you remain the actual author of your software.
Quickstart
- Create an account on the home page with email, password, or Google. You'll receive an
aml-…Plovane ID, your permanent developer identity. - Open the Project Library and start a new project from a verified template.
- Build with visual blocks or drop straight into the notebook.
- Run it on a GPU with your private-beta tokens (see GPU tokens).
New accounts land in the Project Library with the full ACI unlocked on the free tier.
Your free tier
Every account includes:
- All five layers, with none of them paywalled.
- GPU compute for running models on a real GPU, with 300 tokens for private-beta members (see GPU tokens).
- 5 GB of storage and 30 grounded AI prompts per month.
- The templates and community helper library.
Pro ($15/mo) adds the App Builder, GitHub export, live collaboration, and external deployment.
The ACI: five layers
The ACI is a dial. You choose how much help you get, and you can turn the dial at any time without losing a line of code.
- 01Templates: verified project structures that run on first launch.
- 02Helper functions: ranked, verified PyTorch helpers.
- 03Blocks: visual pipelines that compile to real PyTorch.
- 04Data: your files, living inside the project.
- 05Notebook: full cell-based control, no help at all.
Templates
Templates are complete, verified project structures, covering the model definition, training loop, and data pipeline, that execute the moment you open them. They remove the setup tax so your first edit is a real change, not boilerplate. Templates are recommended to you based on what you're building.
Helper functions
The Library surfaces ranked PyTorch helper functions drawn from your own projects and the public community library. Every function is verified before it can be recommended, so nothing unverified ever enters your workspace. Pull a helper in with one click and it arrives as readable code.
Blocks
Blocks let you assemble a model visually. Drag layers onto the canvas to think structurally, then read the generated code to be certain of what runs, since every block compiles to real, inspectable PyTorch.
The core palette is color-coded by category (data, preprocessing, model, training, evaluation, math, utility, control) and filterable with a category dropdown, so its 178 blocks stay easy to scan instead of one long alphabetical list. Every block carries a one-line AI-written summary, visible on hover; click its ✨ icon to ask Plovane Bot about that specific block instead of getting redirected to external PyTorch documentation.
Need more than the core palette? Open 📦 Libraries in the palette header to install additional block libraries, NumPy, pandas, scikit-learn, Matplotlib, and more, each with thousands of AI-summarized blocks pulled straight from the real package.
# Conv2d → BatchNorm → ReLU → Linear compiles to:
import torch.nn as nn
model = nn.Sequential(
nn.Conv2d(3, 64, 3),
nn.BatchNorm2d(64),
nn.ReLU(),
nn.Linear(64, 10),
)Data
Every project has a Files tab. Drop in a CSV, an Excel sheet, a .py module, or any data file and it lands in the project's data/ folder, readable from blocks and code alike, e.g. pd.read_csv('data/<file>'). Folders keep larger datasets organized, and everything travels with the project.
Notebook
When you want full manual control, drop into the cell-based notebook. It's the same project you started from a template, and your blocks and helpers are already there as code. Run cells, inspect tensors, and iterate exactly as you would in any notebook, with the rest of the ACI a tab away.
No hallucinated code
Plovane is designed so that AI assistance never makes up an API:
- Proven suggestions: helpers come from a tested library, not a model's guess.
- Transparent output: visual blocks compile to PyTorch you can read and edit.
- Human in control: the AI helps you refactor and find bugs, but it doesn't take the wheel.
- One source of truth: switching views never splits your code.
GPU tokens
Running a model needs a GPU. GPU compute is rolling out through our private beta: beta members get 300 GPU tokens to spend on real compute, and we're opening it to everyone in stages. Tokens, not dollars, are the unit you see and spend.
Tokens are pegged to a fixed value, but the GPU's market price floats. So the cost per hour, in tokens, moves with the live rate: when the GPU is cheap an hour costs fewer tokens; when it's in demand, more. Your 300 tokens therefore buy more or fewer hours over time.
| Property | Value |
|---|---|
| Tokens per beta member | 300 |
| GPU | Pick from several models (RTX 4070 Ti, 4090, 3090, 5090, 3070), sourced live from our GPU marketplace at the cheapest available offer for each |
| Rate | Tokens per hour, set by the live market price — varies by model |
| Billing | Pay-as-you-go: charged for exactly the time your session runs, not a fixed reservation |
Check the live rate any time with GET /user/tokens/rate. It returns the current tokens/hour and roughly how many hours your balance buys.
Using a GPU
GPU compute is pay-as-you-go, not a fixed-hours rental: pick a model from the picker, start a session, and it bills for exactly what elapses. No upfront duration to guess. You'll get a warning at 60, 30, 10, 5, and 1 minute of remaining balance; if it runs out, the session ends on its own and switches to CPU rather than just cutting off.
# 1. see what's available and pick a model
GET /user/tokens/gpus-available
→ { "available_gpus": [{ "gpu_type": "RTX 3070", "tokens_per_hour": 8, ... }, ...] }
# 2. start a session on it
POST /user/tokens/session/start
{ "gpu_type": "RTX 3070" }
→ { "active": true, "mode": "gpu", "remaining_tokens": 300, "remaining_minutes": 2250 }
# 3. poll every ~20s while it's running
GET /user/tokens/session/status
→ { "active": true, "remaining_minutes": 2231, "warning_threshold_min": null }
# 4. stop whenever you're done
POST /user/tokens/session/stop
→ { "active": false, "mode": "cpu" }Bring your own GPU
Already have a GPU, a workstation, a home rig, a lab machine? Register it as an alternative to the marketplace GPU. Running on your own hardware never spends your tokens; it's a separate path from the token ledger entirely.
POST /user/gpu/register
{ "label": "My home 4090", "host": "100.x.x.x:8080" }
→ registered. GET /user/gpu/mine to fetch it, DELETE /user/gpu/mine to remove it.Collaboration
Prototyping is rarely solo. Plovane projects support real-time collaboration:
- Live cursors: see where teammates are working as they work.
- Shared editing: edit the same project at the same time, without stepping on each other.
- Version sync: snapshots and a shared operation log keep everyone aligned.
Invite collaborators by email from the Users panel. Each invite carries per-user permissions, including which layers they can access. Live collaboration is a Pro feature.
Plovane Bot
Plovane Bot, powered by DeepSeek, is a project-aware assistant available from every project. It can see what you're currently working on, so its answers are grounded in your actual code rather than generic advice. Open it from the ✨ Plovane Bot button in the editor toolbar, or ask about a specific block directly from its ✨ icon in the palette.
It follows the same no-hallucination principle as the rest of Plovane: if it isn't sure a PyTorch API behaves the way it's about to describe, it says so instead of guessing. Replies are kept concise by design, capped to a focused answer rather than an open-ended essay.
POST /api/v1/aimlse-bot/chat
{ "message": "Why is my Conv2d shape mismatched?", "project_context": { "active_view": "f2-view" } }
→ { "reply": "…" }API overview
Plovane exposes a REST API. Authenticate by sending your access token as a bearer header:
Authorization: Bearer <access_token>You receive an access token and refresh token on login. Tokens for a given user can only be read or spent by that user (or an admin).
Auth endpoints
| Method | Path | Purpose |
|---|---|---|
| POST | /auth/register | Create an account |
| POST | /auth/login | Email + password sign in |
| POST | /auth/google-userinfo | Google sign in |
| POST | /auth/refresh | Exchange a refresh token |
| GET | /auth/me | Current user profile |
Token endpoints
| Method | Path | Purpose |
|---|---|---|
| GET | /user/tokens/balance/{user_id} | Token balance |
| GET | /user/tokens/rate | Live tokens/hour for the cheapest available GPU |
| GET | /user/tokens/gpus-available | Every available GPU model, cheapest first |
| POST | /user/tokens/session/start | Start a pay-as-you-go GPU session |
| GET | /user/tokens/session/status | Poll the running session (bills elapsed time, returns warnings) |
| POST | /user/tokens/session/stop | Stop the running session |
| GET | /user/tokens/history/{user_id} | Usage history |
| POST | /user/gpu/register | Register or update your own GPU |
| GET | /user/gpu/mine | Get your registered GPU, if any |
| POST | /api/v1/aimlse-bot/chat | Ask Plovane Bot, with project context |
Support
Questions, bug reports, or enterprise enquiries, reach the team at [email protected]. We read everything.