[Thank you note] Product built on Solara

[JovanVeljanoski]

Thank you note

After a long time of tinkering, i decided to take the plunge and build a product on top of solara. In this note I would like to express my gratitude to @maartenbreddels @iisakkirotko for all their help, patience and examples they've shared, as well as to all the members to the community whos questions helped me in the process. Thank you to all.

I built mylexilingo.com, it is entirely in python thanks to solara (+ vue, as it is supported & used by solara) + some other common python libraries.

Note: I do not want this to be seen as a marketing attempt, I am just sharing the site for context, for those interested from a technical perspective.

Why writing this

In case there are some lurkers here that might be asking themselves the same question: should I try to build my project/idea/app etc.. with solara; since I could do it quickly .. but what if I get stuck?

Context

I come from a (data) science background, and programming is not my strong point. Especially most things related to web-dev was completely new, that I had to learn from almost scratch over the past ~6 months or so.

Python is the only (relevant) language i know quite well, so when I decided to build something, i had to make a choice:

1. use a young, untested framework but in the language i know and love, with the promise that it can take me all the way, and start building immediately;
2. use a mature framework, with tons of resources available online, friends can help, etc.. but i would really have to start from 0 in a different world (JS and friends).

After a (very) short deliberation, i decided to jump all in on option 1 fully aware that:

• solara is not a mature framework; small community; limited examples;
• i may or my not get help on here on discord - meaning I could get stuck on stuff
• unclear how many of the "standard" and "expected" features are readily available
• unclear how many bugs or issues they are once you go beneath the surface, and how fast or if they would be solved
• I am not aware of any big-ish project/product built on solara by independent devs out there -> not talking about "demos", "notebooks", "tweets", "🤗 spaces" and the like; but about things that users would whip up their credit card and pay to use a product, and not curse too much while using it (which might have nothing to do with the framework on which said product it is built!)
• LLMs might not know much about it (although this was not a problem at all)
• Other "unknown unknowns" , especially given my lack of experience in the building webapps and stuff like that (meant for the general public, not internal to a company or team).

However:

• I could start right way using a language I am comfortable with
• I knew it have me "the basics" of what I needed, and push those quite hard
• I could experiment with components and functionality interactively in the (jupyter/vscode) notebook (although I rarely did this)
• I could read the source of solara if needed (rarely); read and understand examples right away

Developer experience

It was a mixed bag, but this is entirely subjective.
The positives were the obvious positives:

• Can write/test/iterate very fast - but maybe that is true for everyone that is familiar with their own framework/stack
• Do not need much to setup and get going
• Maintainers almost always (eventually) replied to issues / questions on here (or Discord) with helpful hints or suggestions.
• Can you "frontend" and "backend" in "the sample place" kind of, and i very much like that (strange sentence to write, but some might understand what I mean).

The unexpected (positive) surprises:

• I think i found a nice pattern to work with solara. I definitely did not come up with that, 100% credit to the makers, but it makes so much sense once you get into it. That is.. writing your own components and browser/client logic in vue. Improves performance, and greatly increases with what you can do, compared to the ready-made solara components. You also do not need to care how solara and ipyvuetify expose props and so on, and you can have total control over style and flow of your page/app. The negative side on this is that.. well you need to write JS (but LLMs are really good at it!), and i've ran into exotic issues that I can simply not reproduce in toy examples to share with the maintainers (and i've spent days on this!). However once I discovered this pattern, i decided to double down on solara when in doubt whether i should just move to JS framework early enough in the process and suffer there..

The unexpected (negative) surprise:

• Some features are pay-walled, and that is perfectly fine. The surprise came from the Static Side Generation (SSG) feature that is also pay-walled. This was a bit of a surprise since, it is readily available in JS frameworks (NextJS, NuxtJS, Sveltekit), but also more importantly (for me) at the first/quick glance, the way the documentation is written, you do not get an impression that this feature is behind a pay-wall (again, talking about building a product here, not a quick demo). But maybe this is on me not doing a more careful research at the start!

The negative:

• Solara uses vue 2; which is fine by itself (can do basically everything i want/need), but is a bit outdated and verbose compared to vue 3 (i know that vue 3 support is probably coming soon)
• Documentation can be sparse, missing, or outdated
• Uncertain level of development
• Various features are missing or in their infancy (e.g. cookie support, webhooks, etc..)
• The uncertainty when thinking "am i the first person doing this" for various "common" things while building (most probably i was not, but it felt like that), and hoping i would not get stuck or back myself into a corner.
• The fear of unexpected things happening when 10-100-1000 people use the app simultaneously..
• Various bugs (could get around them in most case)
• Given things are different (by necessity) from other frameworks, it can be frustrating to figure out how things work or why

LLMs

People use AI assisted coding nowadays. Some more, some less. I do - big time! In fact it was because of LLMs that I thought I could do this in the 1st place. Then some people might be worried: "...but solara is such a young framework.. LLMs can't be much help there! ". This is but right and wrong imo, and for me it was completely fine!

There are so many easy tricks you can do to get any LLM to help you: point them to the docs, the source, to examples (cursor is good at this! google has such a large context window you can but most of the source there and ask questions!). There are various ways people go around this.. yeah LLMs can hallucinate a bit when thinking about solara, but overall "they" more helpful than not (after figuring out how to use them; which was not hard thb).

Unsolicited feedback

1. Reactive-ness

As the project grows large-ish, there are many components interacting with each other. Even after working with solara quite a bit, it is still sometimes hard to figure out what is triggered when and why and in what order. Especially if you have global state, callbacks (that are external to your system, like authorization, or webhooks). I wish there was a way to make a sort of.. dependency graph or so, making it easier when debugging. This might be a skill-issue on my side however. (and yes logging helps of course, but does not always answers all of my questions)

2. What is solara: public perception

Form what i see how solara is presented/used publicly (ok this can be limited by my "sphere of influence" or what I am exosed to), it is primarily marketed/presented as a streamlit/panel/gradio alternative. This is perfectly fine! But! Solara can be so much more! Solara has the potential to be the "NuxtJS (because of the vue support)" of python, and potentially you could build proper large products with it, combining the best of python and the best of the JS world. I think presenting it as another dashboard jupyter viz thing is underselling it big time.

For instance, if solara did not exist, I would never ever built mylexiligo.com on top of streamlit or the like (and I know streamlit probably better then solara, and use it way more for my actual job), regardless of LLMs or even AGI :). Just a fact.

I selfishly wish it would grow even 5%-10% of what NuxtJS is today, which would in turn help me build more nonsense on it (instead of constantly being tempted to the darker JS side.. ).

Aside: I do not even pretend to understand how things work internally, but i do see many references to jupyter.. For those interested in the classical webapps setup and development - it would be nice to have a version that is stripped from all jupyter things if that would improve performance / side etc.. (e.g. not interested in running in jupyter at all).

To anyone who considers using solara to build a product kind of thing

You will be frustrated at time, quite a lot, but it is possible (I think?), to do it, and quite fast and simple. Especially if you wanna see if you are market viable, and go super fast and come from the python world.

Besides, if you look at my thing.. anything that is bad/slow/broken/wrong is unlikely to be due to solara (for the most part). But at least what I have built can serve as a some kind sign that more serious things are possible to be built here in this framework (and lets face it, you will probably struggle at some point no matter what framework you use, such is the course of life. Maybe not if you are an expert in JS or so, but then probably you would not be here...).

Anyone interested more about the ins/outs of my journey and challenges met, feel free to reach out.

To the maintainers

I know you guys are a small team, and limited by time and funding and life and everything - nothing in this post is meant as criticism, just my reflection on the journey. Anyway you have done (and are hopefully doing) a hell of a job! I really hope this will grow further (mainly because I really do not want to learn JS properly), but also because i think the foundation is sold (in terms of the concepts employed at least).

And once again thank you for all of your support and for building this thing, so even people like me can build "proper" webapps.

(also feel free to close this at any time, since there is no issue to solve here..)

[maartenbreddels]

Hi Jovan,

thanks you for sharing this! Impressive work, i've tried it out, and it works super smooth (focus, enter/return key). Login, payment, everything just works. Also, perfect timing to get this nice issue number #1000

Please also share this on Discord on the showcase channel, we don't mind at all if you use our channels to advertise your work. I'm thinking we should showcase this on solara.dev (if you don't mind)

Some small things I noticed:

• Could not try before buying
• When I bought, I did not navigate back (had to use the browser back button).

Also, I think the target audience is people who already know the language a bit right? I did not see a way to learn Macedonian, since I had to translate directly.

cheers,

Maarten

[JovanVeljanoski]

Hi,

Also, perfect timing to get this nice issue number #1000
ha, that was completely by accident! Did not even noticed it until you pointed it out. Cool!

About your feedback

Could not try before buying

That's by design - maybe i will regret it, but I am going with that model for now. I might reduce the price (depending on the models cost etc..) but will unlikely give free trials and the like.. I do have some coupons if anyone really wants to try but that's mostly for exceptions (and I just wanted to do it for the sake of doing it).

When I bought, I did not navigate back (had to use the browser back button).
Yeah i think this is just how stripe links work (probably this can be improved if you use the api/programmatic version), but i went with the simplest/fastest way for now - since much of this is new to me. There should be a message instructing you to go back and refresh tho (although refresh should not be necessary in most cases).

There is definitely Macedonian in the "starter kits"! There is also one in the cards sections but you might need to scroll.

Sure, feel free to add it to solara.dev, or use it as a demo for whatever purpose. I will try to keep it running and not break it, but i do not know how good it really is from technical perspective. But it does seem to work on a basic level at least, and somebody better could push the technology further. At least it can serve as a proof of concept that one can build proper services with it.

Going back to solara:
What I really really like, is that I can just (or mostly) use the solara server, and everything else is done with Vue. I can just build a UI with whatever style, components etc.. (the way Vue was meant to be used) and at the end link the relevant props to variables in python and stuff just works.

In the app above - almost everything follows this pattern

import solara

from my_vue_components import MyComponent

@solara.component
def Page():
    MyComponent(*args)

with bunch of functions and tasks. I find it quite elegant. The only exception is my custom Layout component, but there also I do have vue components like the nav bar for example. After I discovered this, that I can do a complete or almost a complete page like this, things became way faster and smoother in the UI. Although the solara provided components are great for prototyping too, and getting the feel of things.

Given the above pattern (maybe i am an exception to this, but hey, it works very well!), having an nice way to import other vue modules would be great! I know there i support for this (explained here: #847), but I do find it a bit verbose with a lot of boilerplate. I wonder if that can be (eventually improved). It would make this pattern i am talking about all the more powerful.

Anyway, thanks again!
(and probably some more issues/questions coming soon... 🫣)

[paddymul]

As someone who watches this project but isn't a contributor, I just wanted to commend @JovanVeljanoski for the excellent feedback here. I'm sure the project maintainers appreciate this type of fresh feedback. As someone who would potentially use Solara for a project, reading this type of review really helps give me confidence in the project. It gives confidence because I can see the people are conscientiously using it, providing feedback, and if I see the feedback, the maintainers haven't deleted that feedback.

Really nice work all around.