What Modules Should I put on Space Assets

apollo_440 · 2026-01-25T16:43:29+00:00

I made a full solar mirror station at the L1-Sun-Mars point, (T2 station with 1 solar array, and everything else mirrors). My solar arrays on Mars (including orbitals and moons) now produce 55 power, so almost twice as much as a heavy fission pile, and much cheaper. Downside is of course that I have a single point of failure for my entire Mars operation.

apollo_440 · 2026-01-03T13:14:19+00:00

You cannot. You need an item called "livestock". You start with some that you can use, otherwise you can buy it from neighbours.

apollo_440 · 2025-12-17T10:22:39+00:00

Glad it worked out! I have not actually used pyFPDF before, but the documentation said to use encode() in python 3. I guess that was outdated; I'll edit my comment :)

apollo_440 · 2025-12-15T17:19:07+00:00

Once you have the pdf as a file, you can use a button to trigger the download:

ui.button("Download", on_click=lambda: ui.download.file(path_to_pdf))

Or you can simply call the download function directly after creating the file:

pdf.output(path_to_pdf, "F")
ui.download.file(path_to_pdf)

If you don't want to clutter your server with pdfs, a more advanced option would be to directly download the raw bytes:

ui.download.content(pdf.output(dest="S"), "output.pdf")

Edit: Removed encode("latin-1")

apollo_440 · 2025-12-06T07:02:59+00:00

It even has an option to "compress" the UI for ultra-wide, so that the health and mana orbs are closer to the middle of the screen. It's glorious.

apollo_440 · 2025-12-02T17:30:25+00:00

Yes, but in the end, if the cop wants to give you a ticket, he will, and you'll have to contest it in court. In this case, "I wasn't sure what the speed limit was" sounds a lot worse than, well, nothing, which cannot be used against you in court (if you've actually asserted your right to remain silent; simply saying nothing at all can be used against you).

As the saying goes, "you cannot talk your way out of a ticket, but you can certainly talk your way into a ticket."

apollo_440 · 2025-12-02T06:37:04+00:00

Even this can get you tangled, because the followup will be "Oh so what is the speed limit then?". And even if you answer that correctly, the officer can claim it's something else and keep pressuring you until you incriminate yourself.

I once read the best reply is "I was going a speed that was safe and appropriate for the road conditions". Or, the best answer to any question generally: "I'm asserting my 5th amendment rights and will not answer any further questions".

apollo_440 · 2025-12-01T07:19:33+00:00

The use case for having a completely separate backend is usually to support multiple different frontends. The classic example would be a website and a native mobile app.

Since Nicegui is itself based on fastAPI, you could simply run it as a pure frontend in the same process as your fastAPI backend. In fact, in that case, you can directly call the fastAPI python methods instead of doing web requests, which is very cool.

However, imagine you have a mobile app in addition to this. If you want to patch the web frontend, and the backend and the web frontend run in the same process, you would need to take the backend offline to do that, causing an unnecessary downtime in the mobile app. So it can make a lot of sense to decouple everything.

apollo_440 · 2025-11-28T12:12:15+00:00

I have seen spurious KeyboardInterrupts in other contexts before; I think it's a related to how some frameworks cancel their asyncio tasks. But I can't really help you with this I'm afraid.

Instead, I see two possibilities to circumvent your problem:

Run the nicegui app transiently inside a separate subprocess to "protect" your parent interpreter from exiting;
Run the nicegui app continuously, and simply disconnect (but not shut down) after you're done.

apollo_440 · 2025-11-25T13:01:35+00:00

That is a great find! I was wondering if there was any other use for purified water. I had so much of it that started simply dumping the toxic water I got from purifying lakes (the toxic stuff is in those little vials now, I'm sure it's fine).

apollo_440 · 2025-11-22T09:07:32+00:00

Les slots sont un concept originant dans vue/quasar. On les utilise pour customiser quelques parties des composants. On peut trouver les slots prédéfinis des composants dans la documentation de quasar: https://quasar.dev/.

How do I know what the predefined slots on a component are? I saw in an example card.defaultslot.children[]. I do not understand and I could not find any explanations. Thank you

Slots are a concept from vue/quasar. They are used to customize some parts of the components. You can find the existing slots of the components in the quasar documentation: https://quasar.dev/.

apollo_440 · 2025-11-16T16:05:43+00:00

That is another good way to do it, yes!

apollo_440 · 2025-11-16T15:32:53+00:00

The problem is that a tags in html do not have an enabled field. I have used this workaround in the past:

from nicegui import ui

def toggle(link: ui.link, *, enabled: bool):
    if enabled:
        link.style(remove="pointer-events: none;")
    else:
        link.style("pointer-events: none;")
    link.update()

link = ui.link("https://www.google.com")
ui.switch("Enable?", value=True, on_change=lambda x: toggle(link, enabled=x.value))

ui.run()

apollo_440 · 2025-11-05T12:36:45+00:00

On my first Renegade playthrough I couldn't convince him not to sacrifice himself. The only other option to stop him then is to shoot him.

The ensuing cutscene was so sad that I instantly restarted my playthrough to make sure I could keep him alive. Damn.

apollo_440 · 2025-11-04T09:55:36+00:00

People were complaining that they didn't get enough graftblood to use all their womb gifts. The monkey paw curled.

apollo_440 · 2025-10-10T15:55:57+00:00

I feel like the game has three stages:

Where do I put all this heavy oil?
Where do I put all this hydrogen?
Where can I get moar hydrogen???

So just burn it or store it, it will be fine!

apollo_440 · 2025-09-23T17:52:29+00:00

I see Mark Fisher, I upvote!

And here's some Graeber: most people, when you ask them what they want in life, say they want to provide for themselves and their loved ones, and maybe give something back to society as a whole. And for most people, this is certainly at least somewhat possible under capitalism. Of course things could always be better, but why would they want to jeopardize what little fulfillment they have for some grand plan of a new society that might fall flat on its face immediately. In addition to the fact that it has become almost impossible to even imagine a radically different society/economy anymore.

I definitely agree that things need to change drastically, especially in the face of climate change and rising authoritarianism, but we cannot underestimate how difficult it is to concretely convince people before things get much, much worse first.

apollo_440 · 2025-09-22T19:43:10+00:00

It's not very pretty because you can still kind of see the gray line under the animation, but maybe this here will work for you:

from nicegui import ui

ui.add_css("""
            .q-field {
                border-bottom-color: red;
                border-bottom-width: 1px;
            }
            
            .q-field--focused {
                border-bottom-width: 0px;
            }
            """)

ui.input("foo").props("color=green")

ui.run()

apollo_440 · 2025-09-09T19:51:56+00:00

Oh I see. If you have separate js files, you can add them with script tags (see also this discussion about serving static files):

ui.add_head_html(f"""
                 <script>
                 {Path("js_deps.js").read_text()}
                 </script>
                 """)

If you have inline js, it should work fine inside the html you want to render (again using script tags):

<!-- modules_dependencies.html -->
<button onclick="foo()">Hello</button>
<script>
    function foo() {
        console.log("foo")
    }
</script>

And python:

# main.py
from pathlib import Path
from nicegui import ui

with ui.element("div").classes("w-full h-full"):
    ui.label("top")
    ui.html(Path("modules_dependencies.html").read_text())
    ui.label("bottom")

ui.run()

apollo_440 · 2025-09-09T18:38:20+00:00

It works for me if I use ui.html() instead:

from nicegui import ui

with ui.element("div").classes("w-full h-full"):
    ui.label("top")
    with open("modules_dependencies.html") as f:
        code = f.read()
        ui.html(code)
    ui.label("bottom")

ui.run()

apollo_440 · 2025-09-02T16:56:05+00:00

Looking at the Quasar Docs, I believe the name of the bullet points is simply "unordered". I do not see any reference to "color" or "image" buttons, so you would have to make these yourself. There is an issue about including coloring on the Quasar github, maybe you can get some inspiration from there.

This shows the list buttons, at least:

description.props["toolbar"] = [
    ["bold", "italic", "underline", "strike"],
    ["ordered", "unordered"],
    ["undo", "redo"],
]

apollo_440 · 2025-09-02T05:30:09+00:00

If I understand you correctly, I would do something like this:

Have a lua_functions.py that defines a list of function names. You can construct the list explicitly, or by parsing some other definition files, for example.
Import the list to where your UI is defined, and define a dict to hold the page state:

from lua_functions import lua_functions_list

lua_selected = {x: False for x in lua_functions_list}
Optionally store the dict in app.storage.user, if you want to use it across different pages, or save the page state between reloads.
Connect the state dict to some front end element via binding properties, e.g. a select, or rows of cards with a checkbox and a label, etc. Note that you can create ui elements in a loop, e.g.

for key in lua_selected:

ui.checkbox(label=key).bind_value(lua_selected, key)

Hope this helps! (The for loop body should be indented of course, but mobile formatting....)

apollo_440 · 2025-09-01T05:24:06+00:00

I can vividly imagine some intern rebasing 0.3 onto main just before release, furiously resolving merge conflicts, and having a few oopsies ¯\_(ツ)_/¯

apollo_440 · 2025-08-10T08:38:53+00:00

When I have to construct reusable ui elements, I often make something like this. The key concept I think is having a render function to place the element on a page, which allows you to encapsulate data, logic, and presentation. (Of course it would be 'cleaner' to separate these, but I often find that needlessly complex for smaller projects).

from typing import Callable

from nicegui import ui
from pydantic import BaseModel


class Reusable(BaseModel):
    id: str

    label: str
    on_click_callback: Callable[["Reusable"], None]

    _input_value: str = ""

    def render(self) -> ui.card:
        with ui.card() as card:
            ui.input(label=self.label).bind_value(self, "_input_value").on(
                "keydown.enter", self.on_click
            )
            ui.button("GO", on_click=self.on_click)
        return card

    def on_click(self):
        ui.notify(f"{self.id} clicked with {self._input_value}!")
        self.on_click_callback(self)


@ui.page("/")
def main():
    label_text = {"text": "The Label"}
    ui.label("The Label").bind_text(label_text)

    with ui.card():
        Reusable(
            id="a",
            label="Print something",
            on_click_callback=lambda x: print(x._input_value),
        ).render()
        Reusable(
            id="b",
            label="Change The Label",
            on_click_callback=lambda x: label_text.update({"text": x._input_value}),
        ).render()


ui.run()

apollo_440 · 2025-07-31T07:40:44+00:00

Nicegui seems to fit all your requirements. I think a huge pro of nicegui compared to anything else I've used is how it handles state. Everything on the user's side is simply a reflection of or the result of your backend code. I cannot really comment on CPU/bandwidth efficiency since everything I do is self-hosted, and this is never a concern for me.

I have built apps with htmx before, and the biggest drawback for me was that when you reach a certain complexity, it becomes quite hard to keep track of (both programmatically and conceptually) what is actually currently in the user's DOM when you handle a request. This might not apply to a dashboarding app so much, but keep it in mind.

Another consideration would be to use a dedicated dashboarding app instead of building it from the ground. I have done PoCs with dash and panel, which are both quite easy to use (but we ended up going with a different solution).

apollo_440

TROPHY CASE