Is Pynecone the Full‑Stack Python Web Framework You’ve Been Waiting For?

What Is Pynecone?

Pynecone is a flexible full‑stack library that lets developers build and deploy highly scalable web applications entirely in Python, eliminating the need to write HTML, CSS, or JavaScript.

It targets both lightweight data‑science prototypes and large multi‑page sites, handling everything from front‑end components to back‑end logic and deployment.

Typical Applications

1. Deploy web‑based machine‑learning apps

Pynecone provides an integrated database for storing prediction labels and model parameters, enabling seamless model loading and inference.

2. Build data‑science visualisation dashboards

Built‑in chart components simplify the creation of dashboards that monitor business operations, supply‑chain status, and application metrics.

3. Rapid prototyping

Because the framework generates a full stack from a single Python project, developers can iterate quickly on lightweight prototypes and obtain fast client feedback.

4. Large‑scale applications

Pynecone compiles Python code into a NextJS/React application, allowing the construction of complex multi‑page sites while still writing UI logic in Python.

Getting Started – Installation

Python ≥ 3.7 and NodeJS ≥ 12.22.0 are required. After installing NodeJS, run: $ pip install pynecone This installs Pynecone and its dependencies.

Creating a New Project

Open a command prompt, create a directory, and initialise the project:

$ mkdir pyne_project
$ cd pyne_project
$ pc init

The pc init command creates a folder pyne_project with files such as pcconfig.py, pyne_project.py, an assets folder for static files, and a .web folder that holds the compiled NextJS output.

The only file you edit is pyne_project.py, which already contains demonstration code. Run the demo with: $ pc run The server starts and the app is reachable at localhost:3000.

Building a Simple Multiply/Divide App

Define a State class that inherits from pc.State:

import pynecone as pc

class State(pc.State):
    starting_value = 1

    def multiply(self):
        self.starting_value *= 2

    def divide(self):
        self.starting_value /= 2

Event handlers ( on_click) will call multiply or divide when the corresponding button is pressed.

Create the front‑end with an index function:

def index():
    return pc.hstack(
        pc.button("Multiply", color_scheme="blue", border_radius="1em", on_click=State.multiply),
        pc.text(State.starting_value, font_size="2em"),
        pc.button("Divide", color_scheme="red", border_radius="1em", on_click=State.divide),
    )

Register and compile the app:

app = pc.App(state=State)
app.add_page(index)
app.compile()

Running pc run shows two buttons (“Multiply” and “Divide”) and the current starting_value. Clicking “Multiply” three times yields 8; clicking “Divide” five times reduces the value accordingly.

You can change the page title by passing a title argument to app.add_page:

app.add_page(index, title="Multiply and Divide App")

How Pynecone Differs from Flask/Django

Unlike Flask, which only handles back‑end logic and requires separate HTML/CSS/JS for the UI, Pynecone lets you write both front‑end and back‑end in Python. It compiles the entire codebase into a NextJS/React application, providing over 50 ready‑made components that accelerate data‑science UI development.

Conclusion

Pynecone is a new full‑stack Python web framework that simplifies building end‑to‑end applications, from simple prototypes to large, scalable sites. It offers an easy‑to‑use API, integrates React components, and promises future deployment capabilities.