Launch HN: Pynecone (YC W23) – Web Apps in Pure Python

I'm not exaggerating but this might just be the highest impact library I've seen. As a backend developer who has lots of great project ideas but bail at the thought of having to use JavaScript and HTML, this library is a godsend!

My only question is why it took so long for someone to implement it? And where are the equivalent libraries for Go, Rust and Java?

I get get benefit from it, and I saw what Dash and plotly can do for people with a bit of Python and a need for a quick UI.

So I get the point of the project, I can see a mathematicians getting value out of this.

Still, I would advice against using this for anything else than a small project (in the current state):

- any action your perform means a round trip to the server. This is why the counter seems so slow. Everytime you click on increment, it goes through the entire internet, ask for +1, and get the answer, then update the page.

- easy things will be easy, but even the average things are going to be hard. Every time you will want something that is not provided out of the box, the workaround is going to be painful.

- you are coding with react, one of the most complicated framework there is, but with a layer of indirection turning it into a black box. You better hope everything goes well because I don't wish debugging that on anyone.

- the database layer is going to bite you if you start to get fancy. Guaranteed.

- if you need this, you probably can't assess security. So no way to know if your website is secured. In fact, you can pretty much bet it is not.

This means if you use it for something big, you will eventually hit some kind of a big wall. Or something kind of painful experience that will possibly harm the project.

But of course, if the alternative is to never having started the project in the first place, you should definitely go for it.

The deployment being a pain for most python dev, this alone will make your life way easier, and 99% of projects don't have more that a few requests per minutes and a couple of pages anyway.

Just know what you get into: this is a trade off, as everything in engineering, not a unicorn.

Also, this is the Y combinator, so I assume there is a bigger plan behind this.

Good luck to the creators though, anything that move the needle even is good to attempt.

I'd love to see something like this. I'm an old computer science guy and would love to write software again. I can write plenty of functionality in Python but I don't really want to learn all the JS stuff. I just don't like it. If I could abstract away the details it would be a big help. I'm not going to build anything that requires scale or commercial performance so I can afford to compromise versus the "purity" of having your own stack.

At first I was very skeptical, but after looking further at the examples I feel like you pretty much nailed the developer experience. I have not used this yet but I will definitely check it out.

Is there a roadmap? I see the GitHub project board is pretty focused on v0.1.20. I am curious what are your plans for client side code via wasm? I feel like that is a critical missing piece for me.

My opinion on this :

* Web with python : yes, make sense, python is very friendly it's kind of the closest to no-code we can do

* No benchmark : ouch, no way I am touching this without knowing, at least in the big picture, what to expect

* Front-end : so this is a wrapper of Chackra UI which is itself a wrapper of React (which is the slowest framework out there) -> not really what I am looking for. I can understand that for some quickly made website this can be OK. For a serious dev I don't think this will have much appeal. I guess you need to target casual users.

* Not much bloat on the dependencies so this is quiet good on that front, I was expecting way worse.

* Your a startup and backed by YC and I see no business plan, priced service nor anything alike This is very suspect, for me as long as I don't understand how you are meant to work in the long run I will not involved myself using your library.

I am probably not your target user, I will stick with flask/tornado for prototyping my back-end and use lesser known but amazingly light and fast front-end framework. Good luck going forward.

I went to the button component page [1] and to the section of the counter and two increment and decrement buttons. Clicking on either takes something like 0.5 seconds for the counter to update it's value.

Using Android and Samsung internet.

Edit: I took a video screenshot https://voicer.com/v/HSpS9

[1] https://pynecone.io/docs/library/forms/button

I inadvertently built something similar:

https://www.pycob.com

We should talk. If your open source roadmap includes getting rid of your npm dependency then we might just migrate to Pynecone for our front-end.

In earlier life, I authored this exact product (including distributed deploy) for a large investment bank and a fintech startup :)

This is immensely valuable to a lot of Python devs, especially in finance/quant community. Great work!

Edit: The reason why this is so impactful is b/c most users have no idea how to build a react app (along with the circus of build/deploy train one typically entails). They just want a quick-and-dirty UI for their Python model they developed in Jupyter or similar. If the model has legs, a separate FE dev would build a fancier front end later.

Looks promising specially if it is available via Open-source with the choice of self hosting. It would be great if you add a library to make it easy for sign up and login to the web apps as this is a feature that is universally needed. (And if you do please keep it part of the OS version)≥

It took me a bunch of iterations to figure out the value prop, but hmm...it's actually pretty good.

I can see all the SwiftUI[0] inspiration in how to make compositions, instead of relying on CSS only.

Recently there was Rux[1] which is JSX in Rails, but that is really only dealing with ergonomics oh having Components in a nice DSL.

Then there is actual deployment story. I recently made a DRF + Next App, and I spent too much time thinking about deployment. And yea, for the volume I need to server, having a single artifact deployed, with SSR, is wonderful.

How is the intellisense support? That's one of the best features of recent JS/TS frameworks on VSCode, and I don't use JetBrains IDEs. Are there JS/CSS escape hatches? Is the goal to focus on speed of deployment or, a Python DSL over JS libraries?

Good luck either way!

[0] https://developer.apple.com/xcode/swiftui/ [1] https://github.com/camertron/rux

I'm extremely familiar with both Plotly Dash and Streamlit, two frameworks which accomplish the same thing. How does this compare?

Please please tell me you're aware of those two and didn't build this unaware of those options.

Background: I was commissioned by a previous employer to fork Plotly Dash and build a drag and drop BI tool with it.

This looks cool. As someone who is CSS challenged, I have been waiting for more frameworks like this (seems similar in concept to pyjamas/vaadin/gwt). Ideally, with an even lower barrier of entry and hopefully well maintained.

EDIT: I see that the website is generated using pynecone itself. Looks very nice - cool stuff.

I started as a backend dev, moved to full-stack and initially didn't find JS too alluring. I've since liked JS for frontend stuff (not so much backend still). I _really_ like Dash for some things but quickly find myself hitting the boundaries of it's use cases.

I will def have to check this out and keep it on my radar. I used to work for a consulting place where we would have to spin up tons of one-off apps and this seems perfect for that.

The delay in increment/decrement example is not acceptable for a web UI that is expected to update instantly. I believe it should be less than 150ms to become noticeable for the user.

Why is the counter demo so slow? If you are compiling to JS/React I would expect it to be close to native perf no?

The slider component needs some work. Would be nice to have the option to update the local UI in realtime as you slide, then send the state change once it's dropped (on_change_end). Right now it's way too laggy and feels unnatural. And you can't be precise with the slider unless you have the indication it's in the right place.

I haven't seen anyone mention Anvil[1] yet, but it lets you "Build web apps with nothing but Python." and is lovely tool that I've successfully used for a handful of side projects.

But as someone who feels most at home with Python, I always love to see new competition in this space.

[1] https://anvil.works/

Is this similar to Unicorn for Django? https://www.django-unicorn.com/

Would love to see someone building a web project with this from scratch. Preferably a Twitch stream or YouTube video.

This will be so useful for Computer Science students to easily have an app ready right after their first semester. (Or even Stats major, etc)

Often times, a webapp creation usually involves student learning JS and all the ecosystem.

Looks great. I am excited to play with it.

One nit, on your landing page it has a typo, missing "framework /that/ doesn't" > Never get locked into a framework doesn't support your existing tech stack.

Also, your Gallery has highly responsive SPAs, but for some reason the counter here[1] is very slow on a cold load

[1] https://pynecone.io/docs/getting-started/introduction

Love the idea. As someone who's not trying to build The Next Big Thing (TM), but just get some stuff done - I appreciate the focus on the basics. A lot of the python webui's are heavily focused on AI/ML related stuff, which is cool - but what about those of us who just want to build an internal tool that does 5 specific things and nothing more? I try to avoid javascript if at all possible, so "python front to back" is really appealing.

I love this! This solves a big problem for me, which is writing/packaging/deploying JS/HTML.

Question: I see that the ORM assumes a SQL backend. Do you have any plans to support key/value stores, or is it easy to change out the ORM?

I'm thinking this would be perfect for deployment into AWS Lambda for the backend, Cloudfront for the front end, and DynamoDB for the data.

This is amazing! Definitely it has advantages over Streamlit in terms of utilities and customization. Please change the name, if you can, as it's conflicting with Pinecone, another good tool I use.

Pyscript is a reasonably popular client side Python in the Browser solution so wondering how your positioned with regards to them ?

I like it. Reminds me of Vaadin and friends.

One question regarding the states: when do I get a new State allocated? Is it with every new tab? It's definitely not per-browser-session: if I open a new tab I seem to get a new state, while undoing a closed tab seems to recover its state with it though.

Also are old states gc'ed?

There are other apps with somewhat similar philosophy like Plotly Dash. The problem I have faced is that it's almost impossible to debug because you cannot step through code the same way you could in a JS app. Do you plan to solve this?

It really reminds me of https://github.com/miyakogi/wdom but also https://github.com/jupyter-widgets/ipywidgets and https://github.com/flexxui/flexx

The only different aspect is that the goal of Pynecone seems to be web apps over the network and not web interfaces to local programs.

This looks fantastic! I've sent it to my friend who's built a few flask websites and always complains there's not enough python web frameworks, I've got one suggestion / question that sounds a bit odd...

On this page [1] when I press Decrement / Increment it feels like there's well over a second delay.

[1] https://pynecone.io/docs/getting-started/introduction

The API seems pretty similar to Streamlit, another library to create data apps with Python Given thar it’s more popular compared to Pynecone based on Github, how do you plan to differentiate? I would love to hear about the way that you compile to NextJS because that’s a challenge with Streamlit. I have looked into your docs for custom components but I wonder if it’s possible to use compiled NextJS and bring my custom components there instead of bringing my components to Python?

Congrats. Looks really cool!

I'm curious how this compares to other efforts like this such as Streamlit? I do like the fact you compile to React/Next.js as that opens up the possibility of tapping into that rich ecosystem.

Also others have mentioned, and it might not be fair, but the name Pinecone (and variations) has sorta been taken at this point by the vector DB startup since they launched first. So I'd just bite the bullet and change this before the cost of switching rises later on.

Niiiice ! So we should also be able to unit test ou components in pytest and debug them with PDB ? Gonna check this out real soon :)

As a react dev turned django dev, I cannot wait to get my hands on this!

Edit: how come the counter example is so slow on my iPhone 11 though ? That seems real weird https://pynecone.io/docs/getting-started/introduction

Looks similar to Nitro https://nitro.h2o.ai/ and Wave https://wave.h2o.ai/ - both open source. Nitro already works with WebAssembly via Pyodide. (Author here)

Maybe this is a silly question, but why not target WASM instead of React/NextJS?

This is great. I received a lot of comments on my previous Python web apps saying it looked kind of scammy or it looked really old. Glad this came out :) Nothing beats true productivity like a frontend Python stack.

Streamlit was nice but it was built for newbie web developers - not web developers who didn't want to touch JS/TS - whereas this hits that niche quite well.

This is wonderful and a much welcome addition for those of us who don't need to pixel peep but still want to assemble a web app quickly to test product market fit.

I'll certainly try to get a feel for what you built and how it differs from stuff like Streamlit. I have a love hate relationship with the latter and constantly looking for a more mature and faster moving alternative.

I've tested Pynecone recently and it's pretty good. I'm wondering how do you intend to create a business around this library.

Well done. Nice idea. Cool that YC invests in open source developer tools.

My only concern would be the time old problem of another level of abstraction. If the user has a problem they need to see if it is their problem, your problem, or a nextjs peoblem.

But it might be worth it for Python enthusiasts to use there language. The single file frontend/backend looks very compelling too.

Love anything that helps developing apps without knowledge of react or typescript etc.

I’ve played quite a bit with Streamlit, and I know lots of demo apps are built with Gradio. These two tools also aim to help build apps with only python. I remember my Streamlit app code turned into a mess when trying to manage state to support multiple user interactions.

Any comparisons with these frameworks?

Thanks

Nice product! I'd be interested to see what it looks like to integrate an old-school style JS "component" like LeafletJS, especially with a plugin like this: https://github.com/Leaflet/Leaflet.markercluster

Impressive that your demo on wrapping React (https://pynecone.io/docs/advanced-guide/wrapping-react) only downloads 2.2mb. That seems quite low for both React and your library. Promising tech!

Hello Nikhil and Alek! Pynecone looks great! I saw your Show HN a couple of months ago, but I hadn't tracked its progress since.

I'm a fellow founder in the Education space; would you be interested in building a series of "Tutorials" (we have to find the best shape for this) of building Pynecone apps?

In the documentation, I don't see any mention of including external libraries. For example, do you have to do something special to use this nostr library with Pynecone?

https://github.com/jeffthibault/python-nostr

I see none has mentioned h2o wave. If also let's you code in python, manage state (per tab/session/user/global) and has a bunch of prebuilt components so you don't have to write html or java script. But what's the difference between them? Idk!

You should feel really proud of building something so big!

That being said, what's with the bad performance? When I go to this page on Mobile: https://pynecone.io/docs/getting-started/introduction

and I press the "increment" button, it lags. It's subtle but would guess it takes over 100ms to respond.

If I mash the button repeatedly, sometimes it will actually lag so bad I can watch it continue to increment to "catch up" after I've stopped pressing.

As a professional full stack with specialization on frontend, this is not something I would find acceptable in boutique products.

This looks really interesting for a simple way to build a rudimentary but full-featured webapp, for example for the intranet.

But I wonder how this can be used with `asyncio`, since the handlers are pure `def` and not `async def`.

Searching the docs for `async` does return any results.

As someone who basically focuses on infra engineering, I sometimes want to throw together quick UIs for automating stuff. Always been terrified of React/Vue. This is practically a godsend - can't wait to build some tools for myself.

Just tried signing up for the hosting waitlist, but the webpage errors with "The domain name zzz@domain.uk does not exist".

I'd suggest removing whatever checking is in place there, unless you plan to keep the gTLDs up to date.

I took a look and didn't see any element to show video (real time video streaming? showing a webcam demo maybe?) which I find like an interesting application. Making GUIs is always a fair amount of work/overhead on whatever you are working on, and I like to stay in Python when possible (I've used REMI (https://github.com/rawpython/remi) to create web apps before in Python). Thanks for creating this. I look forward to updates!

My only interaction in this space is helping out a friend of mine with Streamlit.

I'm surprised you haven't mentioned anything about it in your HN comment, given it seems, at least on the face of it, extremely similar.

Are you able to go into a bit more detail about why Pynecone and not others?

Did you ever consider contributing to Streamlit instead or forking it? if so, why didn't that work out? What do you do better? Etc.

Disclaimer: I'm not too knowledgeable about this niche, however, so if I'm very off-base here then please let me know :)

Very cool. I tried building some demos, looked at the code.

I agree with the comment about being somewhat like SwiftUI (which I like, even though I have only published one app to the App Store).

Looks cool. I am not a web dev. How much Javascript/React/NextJS do I need to learn to build rich custom UI components+behaviour? Can I do it in entirely in Python?

At first glance this looks very cool.

For me to be able to write a cool test app I'd need a working date picker and some kind of radio button feature (so that I could ask you to select a date and then display a list of offers on screen to select.)

I checked the docs and it seems there's a radio button, but no date picker yet.

Plus maybe the option to push a pdf result.

(My usecase: I'm a backend dev for a booking api and it would be fun to quickly build a frontend to test the API on my phone)

Very cool that you built your own production site in Pynecone!

https://github.com/pynecone-io/pcweb

How does Pynecone differentiate from Streamlit, Panel and Dash?

Seems nice, but also very basic. From what i've seen in the examples, the components lack any deeper interaction-ability. Tables seems to lack editing, or any more complex filtering. There is no tree-component (heck, why are all those framework lacking trees?) or any kind of drag n'drop-support. And so on... So seems to be more for creating basic forms and documents, not a state-of-the-art web app.

It's funny that I'm currently going in the completely opposite direction of using JavaScript to build AI apps (with tensorflow.js). I'm a frontend dev of course.

I think using one language for everything does have the benefit of reducing context switching.

It's about picking your comfort language for higher productivity, while making sacrifices somewhere like performance and less idiomatic.

One other recommendation: If you can please don't build the code as Class based. We front end devs thankfully have moved away from this gross paradigm with react and other libraries and frameworks. I do believe this move towards functional code has been one of the reasons the Frontend has had such a rapid improvement in developer tooling and output over the last decade.

Is there any plan on releasing user management libraries or is there a library you would recommend that interfaces with the ORM?

This is really interesting so far.

I think I've found a bug when using f-strings:

    pc.text(f'count: {State.count}'),

outputs:

    count: {state.count}

while...

    pc.text('count: ' + State.count),

outputs:

    count: 123

(I'm otherwise using the counter example, just with a default value of 123.)

so thankful that this space keeps evolving.

modern vanilla JS/TS isn't so bad but as a backend engineer I just cannot stay up with all the associated tooling required for building, packaging, etc. with front ends.

When it's time to put up a front end for something, my productivity craters to like 1% coding, 99% struggling with JS tooling.

This is really crazy. Are we running out of words to name companies:

* https://pinecone.io/ - Long-term Memory for AI

* https://pynecone.io/ - Frontend. Backend. Hosting. Pure Python.

Just one letter difference 'i' -> 'y'. In other context I would suspect phishing.

How performant is it?

It seems like there's a slightly visible lag in some of the interactions (button clicks) in the docs.

This sounds fine for a very narrow subset of use cases which follow the Happy Path but a complete disaster for anything else. I mean, come on, there are so many React devs who struggle to get it right so how on earth is a Python abstraction layer going to be any better? Just learn JS.

I love this. I tried to get a small PoC working last week and encountered a bug on a very trivial case (rendering a python list to an unordered list element), so may be a bit early for my blood, but I'm excited to see how this project matures and will continue to follow along!

Does https://pynecone.io/docs/database/overview use a SQLLite database on the front end (ie a cross compiled version in the browser) or on the server?

This was interesting, saving user state back to the server.

>> All user state is stored on the server. Behind the scenes, events are sent as API calls to update the state on the server. The state delta is then sent to the frontend, which updates the UI to reflect the new state.

Interesting stuff. A few questions:

How does it scale? Your deployment example (self-hosted?) just shows you how to run what looks like a simple server. Do you just run a lot of those and throw a load balancer in between?

Any thoughts on integrating with Django, FastAPI, or Flask?

What about mobile apps?

Went to your docs, saw the counter, pressed the button and saw a delay on increment when clicking a button (the simplest utility imaginable). I don't want to hate, but if THIS has delay I don't even want to think about more complex state updates.

Congratulations on the launch!

At least the site and the example counter app seem heavily dependant on low latency. I'm overseas and it took a second or so for the hamburger menu (on mobile) to open.

Maybe pairing this with edge hosting service like fly.io would make sense.

This looks pretty clean, I actually built a framework when I was at Bank of America ~9 years ago called webgems that’s built on very similar architecture. Even using the repr for rendering nested. Curious if any Contributors worked in it.

So what makes this better than Streamlit for example? Either today or in the future

So the state is managed by backend similar to signalr blazor? If this statement is correct then it's safe to say this approach doesn't scale well.

What would have been interesting is creating blazor web assembly equivalent for python.

Looks really promising. Have you consider some sort of framework construct to more clearly denote where code runs? Might help readability and make it easier to understand perf implications of code vs the model you have now.

Whats the landing page design style called? Vercel? Are they the ones that did it first? I see it everywhere. Because I noticed vercel doing it first I think every website that does it is a vercel company.

As a somewhat active Dash user, I wonder why is it that most of these frameworks have chosen to go this "write-HTML-in-Python" way, instead of what seems to me a much more natural approach: write some basic, stripped down HTML/CSS in a separate file, then connect that automatically to your backend by e.g. using the right IDs.

Let me give an example. In the Increment/Decrement we see the following Python code:

  def index():
    return pc.hstack(
        pc.button(
            "Decrement",
            color_scheme="red",
            border_radius="1em",
            on_click=State.decrement,
        ),
        pc.heading(State.count, font_size="2em"),
        pc.button(
            "Increment",
            color_scheme="green",
            border_radius="1em",
            on_click=State.increment,
        ),
    )

Which is supposed to build the interface for this almost-too-simple example. Note how there is a lot of custom Python code for simple HTML and CSS things that are already directly available in, well, HTML and CSS. This is how it might look like instead (pardon the inline CSS, it's just a quick comment, you can of course make this much better by writing the CSS separately):

  <button id="dec_btn" class="red" style="border-radius: 1em;">Decrement</button>
  <h2 id="count_h" style="display: inline; font-size: 2em">0</h2>
  <button id="inc_btn" class="green" style="border-radius: 1em;">Increment</button>

Then in the Python side, something like:

  pc.event(id='dec_btn', type='on_click', action=State.decrement)
  pc.event(id='inc_btn', type='on_click', action=State.increment)

  # Runs everytime the State changes (or something)
  def global_update():
    pc.print(id="count_h", f'{State.count}')

This way, presentation is separated from business logic, and 'everything in its right place' (c).

I understand that many (most?) Python developers would like to stay away from JS, but I expect that most developers will know 80% of what is needed from basic HTML/CSS in order to do something like this. If they don't, it should be really easy to learn. I mean, come on, basic HTML/CSS is like a foundational building block of computing, and anyway, to write "HTML-in-Python" you still need to learn the basics (and then twist them into their Python doppelganger).

I am curious to know how python is transpired in to JavaScript for tricky cases involving promises/async await Since python usage is quite different from javascript and for promises it doesnt even exists.

Is there by chance a CRUD boilerplate/starter (_NOT_ a to-do app)?

Question, how does your framework compare with Gradio, the other leasing python/full stack framework that most people are using?

How is it better than Gradio, and what additional features does it have?

So I tried the example in the doc: there is a huge latency between the moment I click on "+" and the moment the counter increment.

Is that what we can expect performance wise? What causes this?

Seems similar to https://nicegui.io/ which recently impressed me! Will check this out.

I was excited while I was under the mistaken impression that Pynecone would simplify Python/WebASM. It seems we are very close to that Nirvana.

Cool! I'm working on something similar in Ruby!

Congrats on launching. Looking forward to try it.

How does Pynecone compare to Flet? I've played with the flet framework and it seems to have a ton of potential.

The response time of buttons is glaring. Is it a quirk of the implementation or that the system is slow?

It looks cool, but I'm not clear on what the add is over existing solutions like Plotly/Dash?

As this is a “LaunchHN” instead of a “ShowHN”…what are your plans to monetize this open source project?

Looks nice, reminds me of swiftUI :)

Nice. FYI, on iOS Safari you can’t scroll the page if the swipe starts on a chart component.

wow, this is how heaven looks like.

the world is flooded with js coders, toolkits, drag-and-drool site builders

this is a neat demo but why do I need to get python in the client when it is even easier to get js in the server?

webdev is basically a solved problem at this point

very nice blog. http://virtuelcampus.univ-msila.dz/facsegc/

Might want to think about the name. Pinecone is a relatively recent startup specializing in vector databases.

https://www.pinecone.io/

hm.. making it only do web seems like a missed opportunity. How hard would it be to make it run on native or other platforms?

Your ideas seem really cool. I'm sad that you chose a name so close to another great startup that does vector databases and search. https://www.pinecone.io/

You're headed into a place where some customers may confuse you.

great work! can't help but wonder how this is different from Dash app from Plotly

Great idea.

why should I prefer Pynecone over NiceGUI?

looks like swiftUI

Why should I choose this over Django or Flask?

By using Python in the frontend you mean the Python is transpiled into JS? The frontend uses templating or generates a SPA app?

I don't want to downplay the library, but how hard is Javascript/HTML for the majority of python programmers? You might not make the most beautiful websites, but you can make a functional website if what you're displaying is primarily data to users because you're doing big data/AI and so forth and not setting up a consumer facing marketing platform. What's the use case here?

You could make about a trillion dollars if, instead of asking people to write Python, you just gave them a WYSIWYG and let them build web apps by pointing and clicking like in MS Publisher/Powerpoint. Literally everyone in the world would buy it to make their own web pages.

I get that nerds like to write code, but it is really depressing that we still can't just point and click and share content on the internet, we need to hire a nerd to write some special language just to make some text boxes and images show up on a screen. I mean, it's 2023. We have rovers discovering ice on freaking Mars. But just making a web page by pointing and clicking is impossible, or limited only to specific web hosting companies.