call_end

    • Pl chevron_right

      Aryan Kaushik: Open Forms is now 0.4.0 - and the GUI Builder is here

      news.movim.eu / PlanetGnome • 3 months from now • 3 minutes

    Open Forms is now 0.4.0 - and the GUI Builder is here

    A quick recap for the newcomers

    Ever been to a conference where you set up a booth or tried to collect quick feedback and experienced the joy of:

    • Captive portal logout
    • Timeouts
    • Flaky Wi-Fi drivers on Linux devices
    • Poor bandwidth or dead zones

    Meme showcasing wifi fails when using forms

    This is exactly what happened while setting up a booth at GUADEC. The Wi-Fi on the Linux tablet worked, we logged into the captive portal, the chip failed, Wi-Fi gone. Restart. Repeat.

    Meme showing a person giving their child a book on 'Wifi drivers on linux' as something to cry about

    We eventually worked around it with a phone hotspot, but that locked the phone to the booth. A one-off inconvenience? Maybe. But at any conference, summit, or community event, at least one of these happens reliably.

    So I looked for a native, offline form collection tool. Nothing existed without a web dependency. So I built one.

    Open Forms is a native GNOME app that collects form inputs locally, stores responses in CSV, works completely offline, and never touches an external service. Your data stays on your device. Full stop.

    Open Forms pages

    What's new in 0.4.0 - the GUI Form Builder

    The original version shipped with one acknowledged limitation: you had to write JSON configs by hand to define your forms.

    Now, I know what you're thinking. "Writing JSON to set up a form? That's totally normal and not at all a terrible first impression for non-technical users." And you'd be completely wrong, to me it was normal and then my sis had this to say "who even thought JSON for such a basic thing is a good idea, who'd even write one" which was true. I knew it and hence it was always on the roadmap to fix, which 0.4.0 finally fixes.

    Open Forms now ships a full visual form builder.

    Design a form entirely from the UI - add fields, set labels, reorder things, tweak options, and hit Save. That's it. The builder writes a standard JSON config to disk, same schema as always, so nothing downstream changes.

    It also works as an editor. Open an existing config, click Edit, and the whole form loads up ready to tweak. Save goes back to the original file. No more JSON editing required.

    Open forms builder page

    Libadwaita is genuinely great

    The builder needed to work well on both a regular desktop and a Linux phone without me maintaining two separate layouts or sprinkling breakpoints everywhere. Libadwaita just... handles that.

    The result is that Open Forms feels native on GNOME and equally at home on a Linux phone, and I genuinely didn't have to think hard about either. That's the kind of toolkit win that's hard to overstate when you're building something solo over weekends.


    The JSON schema is unchanged

    If you already have configs, they work exactly as before. The builder is purely additive, it reads and writes the same format. If you like editing JSON directly, nothing stops you. I'm not going to judge, but my sister might.

    Also thanks to Felipe and all others who gave great ideas about increasing maintainability. JSON might become a technical debt in future, and I appreciate the insights about the same. Let's see how it goes.

    Install

    Snap Store

    snap install open-forms
    

    Flatpak / Build from source

    See the GitHub repository for build instructions. There is also a Flatpak release available .

    What's next

    • A11y improvements
    • Maybe and just maybe an optional sync feature
    • Hosting on Flathub - if you've been through that process and have advice, please reach out

    Open Forms is still a small, focused project doing one thing. If you've ever dealt with Wi-Fi pain while collecting data at an event, give it a try. Bug reports, feature requests, and feedback are all very welcome.

    And if you find it useful - a star on GitHub goes a long way for a solo project. 🙂

    Open Forms on GitHub

    • Pl chevron_right

      Thibault Martin: I realized that I created too much friction to publish

      news.movim.eu / PlanetGnome • 10:00 • 2 minutes

    I love writing on my blog. I love taking a complex topic, breaking it down, understanding how things work, and writing about how things clicked for me. It serves a double purpose:

    1. I can organize my thoughts, ensure I understood the topic fully, and explain it to others.
    2. It helps my future self: if I forgot about the topic, I can read about what made it click for me.

    But as of writing, the last time I published something on my blog was 5 months ago.

    The blogging process

    My blog posts tend to be lengthy. My writing and publishing process is the following.

    1. Take a nontrivial topic, something I didn't know about or didn't know how to do.
    2. Understand it, break it down, and get a clear picture of how things work.
    3. Write an outline for the post with the key points.
    4. Ask my smarter friends if the outline makes sense.
    5. Flesh out the outline into a proper blog posts, with all the details, code snippets, screenshots.
    6. Ask my smarter friends to review the post again.
    7. Get an illustrator to create a banner for the post, that also serves as an opengraph preview image.
    8. Publish the post.

    That is a lot of work. I have many posts stuck between step 3 and 5, because they take quite a bit of time. Asking an illustrator to create a banner for the post also creates more friction: obviously I need to pay the illustrator, but I also need to wait for him to be done with the illustration.

    Not everything has to be a blog post

    Sometimes I have quick thoughts that I want to jot down and share with the rest of the world, and I want to be able to find it back. There are two people I follow that write a lot, often in short format.

    1. John Gruber on his blog Daring Fireball .
    2. Simon Willison, on his Weblog .

    Both of them have very short format notes. Willison even blogged about what he thinks people should write about .

    Reducing friction and just posting

    I don't think friction should be avoided at all costs. Take emails for example: there's a delay between when you send a message and your peer receives it, or the other way around. That friction encourages longer form messages, which gives more time to organize thoughts.

    I also welcome the friction I have created for my own posts: I get through a proper review process and publish higher quality posts.

    But there's also room for spontaneity. So I've updated my website to let me publish two smaller formats:

    • TILs. Those are short posts about something I've learned and found interesting.
    • Thoughts. Those are shorter posts I jot down in less than 20 minutes to develop simple thoughts.
    • Pl chevron_right

      Gedit Technology: gedit 50.0 released

      news.movim.eu / PlanetGnome • 10:00 • 2 minutes

    gedit 50.0 has been released! Here are the highlights since version 49.0 from January. (Some sections are a bit technical).

    No Large Language Models AI tools

    The gedit project now disallows the use of LLMs for contributions.

    The rationales:

    Programming can be seen as a discipline between art and engineering. Both art and engineering require practice. It's the action of doing - modifying the code - that permits a deep understanding of it, to ensure correctness and quality.

    When generating source code with an LLM tool, the real sources are the inputs given to it: the training dataset, plus the human commands.

    Adding something generated to the version control system (e.g., Git) is usually frown upon. Moreover, we aim for reproducible results (to follow the best-practices of reproducible builds, and reproducible science more generally). Modifying afterwards something generated is also a bad practice.

    Releasing earlier, releasing more often

    To follow more closely the release early, release often mantra, gedit aims for a faster release cadence in 2026, to have smaller deltas between each version. Future will tell how it goes.

    The website is now responsive

    Since last time, we've made some efforts to the website. Small-screen-device readers should have a more pleasant experience.

    libgedit-amtk becomes "The Good Morning Toolkit"

    Amtk originally stands for "Actions, Menus and Toolbars Kit". There was a desire to expand it to include other GTK extras that are useful for gedit needs.

    A more appropriate name would be libgedit-gtk-extras. But renaming the module - not to mention the project namespace - is more work. So we've chosen to simply continue with the name Amtk, just changing its scope and definition. And - while at it - sprinkle a bit of fun :-)

    So there are now four libgedit-* modules:

    • libgedit-gfls , aka "libgedit-glib-extras", currently for "File Loading and Saving";
    • libgedit-amtk , aka "libgedit-gtk-extras" - it extends GTK for gedit needs at the exception of GtkTextView;
    • libgedit-gtksourceview - it extends GtkTextView and is a fork of GtkSourceView, to evolve the library for gedit needs;
    • libgedit-tepl - the Text Editor Product Line library, it provides a high-level API, including an application framework for creating more easily new text editors.

    Note that all of these are still constantly in construction.

    Some code overhaul

    Work continues steadily inside libgedit-gfls and libgedit-gtksourceview to streamline document loading .

    You might think that it's a problem solved (for many years), but it's actually not the case for gedit. Many improvements are still possible.

    Another area of interest is the completion framework (part of libgedit-gtksourceview), where changes are still needed to make it fully functional under Wayland. The popup windows are sometimes misplaced. So between gedit 49.0 and 50.0 some progress has been made on this. The Word Completion gedit plugin works fine under Wayland, while the LaTeX completion with Enter TeX is still buggy since it uses more features from the completion system.

    • Pl chevron_right

      Sebastian Wick: Three Little Rust Crates

      news.movim.eu / PlanetGnome • 1 day ago • 2 minutes

    I published three Rust crates:

    • name-to-handle-at : Safe, low-level Rust bindings for Linux name_to_handle_at and open_by_handle_at system calls
    • pidfd-util : Safe Rust wrapper for Linux process file descriptors (pidfd)
    • listen-fds : A Rust library for handling systemd socket activation

    They might seem like rather arbitrary, unconnected things – but there is a connection!

    systemd socket activation passes file descriptors and a bit of metadata as environment variables to the activated process. If the activated process exec’s another program, the file descriptors get passed along because they are not CLOEXEC . If that process then picks them up, things could go very wrong. So, the activated process is supposed to mark the file descriptors CLOEXEC , and unset the socket activation environment variables. If a process doesn’t do this for whatever reason however, the same problems can arise. So there is another mechanism to help prevent it: another bit of metadata contains the PID of the target. Processes can check it against their own PID to figure out if they were the target of the activation, without having to depend on all other processes doing the right thing.

    PIDs however are racy because they wrap around pretty fast, and that’s why nowadays we have pidfds. They are file descriptors which act as a stable handle to a process and avoid the ID wrap-around issue. Socket activation with systemd nowadays also passes a pidfd ID. A pidfd ID however is not the same as a pidfd file descriptor! It is the 64 bit inode of the pidfd file descriptor on the pidfd filesystem. This has the advantage that systemd doesn’t have to install another file descriptor in the target process which might not get closed. It can just put the pidfd ID number into the $LISTEN_PIDFDID environment variable.

    Getting the inode of a file descriptor doesn’t sound hard. fstat(2) fills out struct stat which has the st_ino field. The problem is that it has a type of ino_t , which is 32 bits on some systems so we might end up with a process identifier which wraps around pretty fast again.

    We can however use the name_to_handle syscall on the pidfd to get a struct file_handle with a f_handle field. The man page helpfully says that “the caller should treat the file_handle structure as an opaque data type”. We’re going to ignore that, though, because at least on the pidfd filesystem, the first 64 bits are the 64 bit inode. With systemd already depending on this and the kernel rule of “don’t break user-space”, this is now API, no matter what the man page tells you.

    So there you have it. It’s all connected.

    Obviously both pidfds and name_to_handle have more exciting uses, many of which serve my broader goal: making Varlink services a first-class citizen. More about that another time.

    • Pl chevron_right

      This Week in GNOME: #242 Shuffling Cards

      news.movim.eu / PlanetGnome • 1 day ago • 6 minutes

    Update on what happened across the GNOME project in the week from March 20 to March 27.

    GNOME Releases

    Sophie (she/her) reports

    GNOME 48.10 has been released . This is the final release for GNOME 48. If you are still using the GNOME 48 runtime on Flathub, you can update to the GNOME 50 runtime directly. The GNOME 48 runtime will be marked as end of life (EOL) on April 11. Apps that are still using the runtime at this point will trigger warnings for their users.

    GNOME Core Apps and Libraries

    Khalid Abu Shawarib reports

    Version 50 of Fonts was released this week!

    This release includes a redesigned fonts preview grid that is more responsive when scrolling, and have a uniform text baseline.

    Moreover, the search bar is now always visible, and supports type-to-search in the main font preview grid.

    fonts-main.Q4GT3vxA_Z1nb2AX.webp

    Python Bindings (PyGObject)

    Python language bindings for GNOME platform libraries.

    Arjan announces

    PyGObject 3.56.2 has been released. This release contains a few fixes:

    • Fix issue when do_dispose is called while the garbage collector is running.
    • retain object floating state for get-/set-property calls.

    As always, the latest version is available on PyPI and the GNOME download server .

    GNOME Circle Apps and Libraries

    Sophie (she/her) says

    As you may already have learned from the GNOME 50 release notes, Sessions has been accepted into GNOME Circle.

    Sessions is a simple visual timer application designed specifically for the pomodoro technique. The app is maintained by Felicitas Pojtinger.

    gnome-circle-sessions.DmdKFJNQ_Z1rD29E.webp

    Warp

    Fast and secure file transfer.

    Fina reports

    Warp 1.0 has been released, finally breaking the light speed barrier. New features include a new shortcuts dialog, runtime and translation updates. Engage!

    warp.pQiymWGN_2g19e2.webp

    Video Trimmer

    Trim videos quickly.

    YaLTeR reports

    I released Video Trimmer 26.03 with an improvement suggested by one of the users: the prefilled filename in the save dialog now includes the trimming timestamps. This way, there are no filename conflicts when extracting several fragments from a video.

    I also added several CLI flags to pre-set the start and end timestamp, and the precise trim and remove audio options.

    video%20trimmer.C9bzpxuU_bVBRn.webp

    Identity

    Compare images and videos.

    YaLTeR reports

    Identity 26.03 is out with a new time display when hovering the mouse over the video seek bar. I also added Ctrl+2..9 hotkeys to set the zoom level from 200% to 900%.

    The window title now shows the current filename, which is helpful with many open tabs. Finally, you can pass the initial --zoom and --display mode on the command line.

    Third Party Projects

    Haydn Trowell reports

    The latest version of Typesetter, the minimalist Typst editor, brings:

    • Built-in, automatic grammar checking (currently English only).
    • Tooltips for Typst errors and warnings in the editor.
    • Keyboard shortcuts for navigating spelling errors.
    • New translations: Czech (p-bo), Dutch (flipflop97), Finnish (Jiri Grönroos), Polish (michalfita), Swedish (haaninjo), and Vietnamese (namthien).

    Get it on Flathub: https://flathub.org/apps/net.trowell.typesetter

    If you want to help bring Typesetter to your language, translations can be contributed via Weblate: https://translate.codeberg.org/engage/typesetter/

    Andrea Fontana announces

    Hideout is a simple, GTK-based encryption tool written in D, designed specifically for non-technical users who need to password-protect their files without complexity. It follows GNOME’s design principles to provide a clean and intuitive experience. On Flathub: https://flathub.org/apps/it.andreafontana.hideout

    Jeffry Samuel reports

    Nocturne has been released, it allows users to manage their local music libraries with optional Navidrome / Subsonic integration. It includes features such as:

    • Playlists
    • Automatic lyrics fetching
    • Play queue managing
    • Album and artist sorting
    • Fast searching

    For more information visit the website or repository

    https://jeffser.com/nocturne/ https://github.com/Jeffser/Nocturne

    nocturne.XaAB1HEy_ZsW8nw.webp

    nocturne0.D9FoNEgL_1cuzRF.webp

    nocturne2.BnY_BIId_Z1iKUGB.webp

    Anton Isaiev says

    RustConn (connection manager for SSH, RDP, VNC, SPICE, Telnet, Serial, Kubernetes, MOSH, and Zero Trust protocols)

    Versions 0.10.3–0.10.8 landed this week with changes driven entirely by user feedback:

    • Security : RDP passwords no longer exposed in /proc; SSH agent passphrase files are zeroized before deletion; legacy XOR credentials migrated to AES-256-GCM transparently
    • Embedded viewer performance : eliminated per-frame pixel buffer allocations (8–33 MB depending on resolution) for SPICE, VNC, and RDP by switching to persistent Cairo surfaces with in-place updates; RDP frame extraction now uses row-based memcpy + bulk SIMD-friendly R↔B swap
    • HiDPI fixes : resolved blurry/artifact RDP rendering on HiDPI displays caused by double-scaling; fixed cursor artifacts from transparent padding bleed on scaled displays
    • Flatpak sandbox : Zero Trust CLIs (gcloud, Azure, Teleport, OCI) now work correctly by redirecting config paths to writable sandbox directories; fixed CLI detection using extended PATH
    • KeePassXC integration : fixed all vault operations failing when KDBX file is password-protected (password was passed as None in 10 call sites)
    • Passbolt CLI 0.4.2 compatibility : fixed deserialization failures from field naming changes
    • Highlight rules : built-in defaults (ERROR, WARNING, CRITICAL, FATAL) now always apply, not just when per-connection rules exist
    • Code quality : shared CairoBackedBuffer module, deduplicated regex compilations, extracted parse_protocol_type() to eliminate 3 duplicate implementations

    Thank you for the growing interest in RustConn. All of this work is driven purely by user feedback - every bug report and feature request shapes the project. I reached what I considered “my ideal” months ago, but it turns out users know better. The result is an open-source connection manager that, in my honest opinion, is now more capable and convenient than its commercial competitors - built by engineers, for engineers.

    A special thanks to the community members who package RustConn for AUR and other distribution repositories, and to those who ported it to FreeBSD. Seeing people take the time to bring RustConn to new platforms is the strongest signal that the project fills a real need.

    Constructive feedback is always welcome: https://github.com/totoshko88/RustConn/issues Project: https://github.com/totoshko88/RustConn Flatpak: https://flathub.org/en/apps/io.github.totoshko88.RustConn

    rustconn.C5A6qSRc_1y6qeJ.webp

    xjuan reports

    Cambalache’s First Major Milestone!

    After more than 5 years, 1780 commits and 20k lines of handcrafted, artisanal Python code I am very pleased to announce Cambalache 1.0 !!!

    Cambalache is a WYSIWYG (What You See Is What You Get) tool that allows you to create and edit user interfaces for Gtk 4 and 3 applications.

    Read more about it at https://blogs.gnome.org/gtk/2026/03/20/cambalaches-first-major-milestone/

    cambalache.Bkbl_WOQ_1BRmBc.webp

    Solitaire

    Play Patience Games

    Will Warner announces

    Solitaire is a new app to play paitence games! It has been about a year since I started working on this, and I am excited to say that Solitaire is now avalible on Flathub . Solitaire has a solver that will tell you if the game you are playing has become impossible to win, and provides hints that are guaranteed to lead to a win. The app features six games: Klondike, FreeCell, Tri Peaks, Spider, Pyramid, and Yukon. Solitaire will also keep track of your scores, using moves or time based scoring. It even lets you change what the cards look like, with seven card themes to choose from.

    Solitaire-TWIG-242.CUw4Khhy_ZAsB9u.webp

    Shell Extensions

    sri 🚀 says

    GNOME Shell extensions reviews have become delayed due to our main reviewer being cut off from the Internet. The backlog is getting long and while some community members have stepped up the progress is slow. Much appreciation to those who are stepping up. Please be aware that the review delay means that extensions being updated to GNOME 50 are being delayed.

    That’s all for this week!

    See you next week, and be sure to stop by #thisweek:gnome.org with updates on your own projects!

    • Pl chevron_right

      Lennart Poettering: Mastodon Stories for systemd v260

      news.movim.eu / PlanetGnome • 1 day ago • 1 minute

    On March 17 we released systemd v260 into the wild .

    In the weeks leading up to that release (and since then) I have posted a series of serieses of posts to Mastodon about key new features in this release, under the #systemd260 hash tag. In case you aren't using Mastodon, but would like to read up, here's a list of all 21 posts:

    I intend to do a similar series of serieses of posts for the next systemd release (v261), hence if you haven't left tech Twitter for Mastodon yet, now is the opportunity.

    My series for v261 will begin in a few weeks most likely, under the #systemd261 hash tag.

    In case you are interested, here is the corresponding blog story for systemd v259 , here for v258 , here for v257 , and here for v256 .

    • Pl chevron_right

      Andy Wingo: free trade and the left, quater: witches

      news.movim.eu / PlanetGnome • 2 days ago • 9 minutes

    Good evening. Tonight, we wrap up our series on free trade and the left. To recap where we were, I started by retelling the story that free trade improves overall productivity , but expressed reserves about the way in which it does so: plant closures and threats thereof, regulatory arbitrage, and so on. Then we went back in history, discussing the progressive roots of free trade as a cause of the peace-and-justice crowd , in the 19th century. Then we looked at the leading exponents of free trade in the 20th century, the neoliberals , ending in an odd place: instead of free trade being a means for the end of peace and prosperity, neoliberalism turns this on its head, instead holding that war, immiseration, apartheid, dictatorship, ecological disaster, all are justified if they serve the ends of the “free market”, of which free trade is a component.

    When I make this list of evils I find myself back in 1999, that clearly “we” were right then to shut down the WTO meetings in Seattle. With the distance of time, I start to wonder, not about then, but about now: for all the evil of our days, Trump at least has the virtue of making clear that trade barriers have a positive dot-product with acts of war. As someone who lives in the banlieue of Geneva, I am always amused when I find myself tut-tutting over the defunding of this or that institution of international collaboration.

    I started this series by calling out four works. Pax Economica and Globalists have had adequate treatment. The third, Webs of Power , by Starhawk, is one that I have long seen as a bit of an oddball; forgive my normie white boy (derogatory) sensibilities, but I have often wondered how a book by a voice of “earth-based spirituality and Goddess religion” has ended up on my shelf. I am an atheist. How much woo is allowed to me?

    choice of axiom

    Conventional wisdom is to treat economists seriously, and Wiccans less so. In this instance, I have my doubts. The issue is that a neoliberal is at the same time a true believer in markets, and a skilled jurist. In service of the belief, any rhetorical device is permissible, if it works; if someone comes now and tries to tell me that the EU-Mercosur agreement is a good thing because of its effect on capybara populations, my first reaction is to doubt them, because maybe they are a neoliberal, and if so they would literally say anything .

    Whereas if Starhawk has this Earth-mother-spiritual vibe... who am I to say? Yes, I think religion on the whole is a predatory force on vulnerable people, but that doesn’t mean that her interpretation of the web of life as divine is any less legitimate than neoliberal awe of the market. Let’s hear her argument and get on with things.

    Starhawk’s book has three parts. The first is an as-I-lived-it chronicle, going from Seattle to Washington to Prague to Quebec City to Genoa, and thence to 9/11 and its aftermath, describing what it was like to be an activist seeking to disrupt the various WTO-adjacent meetings, seeking to build something else. She follows this up with 80 pages of contemporary-to-2002 topics such as hierarchy within the movement, nonviolence vs black blocs, ecological principles, cultural appropriation, and so on.

    These first two sections inform the last final 20 pages, in which Starhawk attempts to synthesize what it is that “we” wanted, as a kind of memento and hopefully a generator of actions to come. She comes up with a list of nine principles, which I’ll just quote here because I don’t have an editor (the joke’s on all of us!):

    1. We must protect the viability of the life-sustaining systems of the planet, which are everywhere under attack.
    2. A realm of the sacred exists, of things too precious to be commodified, and must be respected.
    3. Communities must control their own resources and destinies.
    4. The rights and heritages of indigenous communities must be acknowledged and respected.
    5. Enterprises must be rooted in communities and be responsible to communities and to future generations.
    6. Opportunity for human beings to meet their needs and fulfill their dreams and aspirations should be open to all.
    7. Labor deserves just compensation, security, and dignity.
    8. The human community has a collective responsibility to assure the basic means of life, growth, and development for all its members.
    9. Democracy means that all people have a voice in the decisions that affect them, including economic decisions.

    Now friends, this is Starhawk’s list, not mine, and a quarter-century-old list at that. I’m not here to judge it, though I think it’s not bad; what I find interesting is its multifaceted nature, that when contrasted with the cybernetic awe of late neoliberalism, that actually it’s the Witch who has the more down-to-earth concerns: a planet to live on, a Rawlsian concern with justice, and a control of the economic by the people.

    which leaves us

    Former European Central Bank president Mario Draghi published a report some 18 months ago diagnosing a European malaise and proposing a number of specific remedies. I find that we on my part of the left are oft ill-equipped to engage with the problem he identifies, not to mention the solutions. The whole question of productivity is very technical, to the extent that we might consider it owned by our enemies: our instinct is to deflect, “productivity for what”, that sort of thing. Worse, if we do concede the problem, we haven’t spent as much time sparring in the gyms of comparative advantage; we risk a first-round knockout. We come with Starhawk’s list in hand, and they smile at us condescendingly: “very nice but we need to focus on the economy, you know,” and we lose again.

    But Starhawk was not wrong. We do need a set of principles that we can use to analyze the present and plot a course to the future. I do not pretend to offer such a set today, but after having looked into the free trade question over the last couple months, I have reached two simple conclusions, which I will share with you now.

    The first is that, from an intellectual point of view, we should just ignore the neoliberals; they are not serious people . That’s not a value judgment on the price mechanism, but rather one on those that value nothing else: that whereas classical liberalism was a means to an end, neoliberalism admits no other end than commerce, and admits any means that furthers its end. And so, we can just ignore them . If neoliberals were the only ones thinking about productivity, well, we might need new branches of economics. Fortunately that’s not the case. Productivity is but one dimension of the good, and it is our collective political task to choose a point from the space of the possible according to our collective desires.

    The second conclusion is that we should take back free trade from our enemies on the right. We are one people, but divided into states by historical accident. Although there is a productivity argument for trade, we don’t have to limit ourselves to it: the bond that one might feel between Colorado and Wyoming should be the same between Italy and Tunisia, between Canada and Mexico, indeed between France and Brasil. One people, differentiated but together, sharing ideas and, yes, things. Internationalism, not nationalism.

    There is no reason to treat free trade as the sole criterion against which to judge a policy. States are heterogeneous: what works for the US might not be right for Haiti; states differ in the degree that they internalize environmental impacts; and they differ as regards public services. We can take these into account via policy, but our goal should be progress for all.

    So while Thomas Piketty is right to decry a kind of absolutism among European decisionmakers regarding free trade , I can’t help but notice a chauvinist division being set up in the way we leftists are inclined to treat these questions: we in Europe are one bloc, despite e.g. very different carbon impacts of producing a dishwasher in Poland versus Spain, whereas a dishwasher from China belongs to a different, worse, more sinful category.

    and mercosur?

    To paraphrase Marley’s ghost, mankind is my business . I want an ever closer union with my brothers and sisters in Uruguay and Zambia and Cambodia and Palestine. Trade is a part of it. All things being equal, we should want to trade with Chile. We on the left should not oppose free trade with Mercosur out of a principle that goods produced far away are necessarily a bad thing.

    All this is not to say that we should just doux it (although, gosh, Karthik is such a worthy foe); we can still participate in collective carrot-and-stick exercises such as carbon taxes and the like, and this appreciation of free trade would not have trumped the campaign to boycott apartheid South Africa, nor would it for apartheid Israel. But our default position should be to support free trade with Mercosur, in such a way that does improves the lot of all humanity.

    I don’t know what to think about the concrete elements of the EU-Mercosur deal. The neoliberal play is to design legal structures that encase commerce, and a free trade deal risks subordinating the political to the economic. But unlike some of my comrades on the left, I am starting to think that we should want free trade with Bolivia, and that’s already quite a change from where I was 25 years ago.

    fin

    Emily Saliers famously went seeking clarity ; I fear I have brought little. We are still firmly in the world of the political, and like Starhawk, still need a framework of pre-thunk thoughts to orient us when some Draghi comes with a new four-score-page manifesto. Good luck and godspeed.

    But it is easier to find a solution if we cull the dimensionality of the problem. The neoliberals had their day, but perhaps these staves may be of use to you in exorcising their discursive domination; it is time we cut them off. Internationalist trade was ours anyway, and it should resume its place as a means to our ends.

    And what ends? As with prices, we discover them on the margin, in each political choice we make. Some are easy; some less so. And while a list like Starhawk’s is fine enough, I keep coming back to a simpler question: which side are you on? The sheriff or the union? ICE or the immigrant? Which side are you on? The question cuts fine. For the WTO in Seattle, to me it said to shut it all down. For EU-Mercosur, to me it says, “let’s talk.”

    • Pl chevron_right

      Thibault Martin: TIL that Proxmox can provision Kubernetes Persistent Volumes

      news.movim.eu / PlanetGnome • 3 days ago • 2 minutes

    I wanted to dip my toes into Kubernetes for my homelab, but I knew I would need some flexibility to experiment. So instead of deploying k3s directly on my server, I

    1. Installed a base Debian on my server, encrypting the disk with LUKS and using LVM to partition it.
    2. Installed the Proxmox hypervisor on that base Debian
    3. Spun up a Debian VM, and installed k3s on it.

    Proxmox supports several storage plugins . It allows me to create LVM Local Volumes for the VM disks for example.

    This setup allows me to spin up fresh VMs for my experiments, all while leaving my production k3s intact. This is great, but it came up with two problems:

    1. When I provision the VM for k3s I need to allocate it a massive amount of disk space. This is because k3s uses a local path provisioner to provision new Persistent Volumes directly on the VM.
    2. I can't take snapshots of the Persistent Volumes when doing backups. There's a risk that the data will change while I perform the backup.

    The situation looks like the following.

    On the LVM disk of the host, I create a VM for k3s. This VM has a virtual disk that doesn't rely on LVM, so it can't create LVM Logical Volumes. The local provisioner can only create volumes on the virtual disk, because it can't escape the VM to create volumes on the Proxmox host.

    Because the volumes are created on the virtual disk that doesn't rely on LVM, I can't use LVM snapshots to take snapshots of my volumes.

    [!question] Why not LVM Thin?

    One solution to address the massive disk requirement could be to use LVM Thin : it would allow me to allocate a lot of space in theory, but in practice in only fills up as the VM storage gets used.

    I don't want to use LVM Thin because it puts me at risk of overprovisioning. I could allocate more storage than I actually have, and it would be difficult to realize that my disks are filling up before it's too late.

    My colleague Quentin mentioned the Proxmox CSI Plugin . It is a plugin that replaces k3s' local path provisioner. Instead of creating the kubernetes Persistent Volumes inside the VM, it calls the Proxmox host, asks it to create a LVM Logical Volume and binds it to a Persistent Volume in kubernetes.

    Using the Proxmox CSI volume, the situation would look like this.

    It solves the two problems for me:

    1. I can now only provision a small disk for the k3s VM, since the Persistent Volumes will be created outside of the VM.
    2. Since Proxmox will create LVM Logical Volumes to provision the Persistent Volumes, I can either do a LVM Snapshot from Proxmox or use Kubernete's Volume Snapshot feature, with some caveats .

    Setting up the Proxmox-CSI-Plugin for k3s can be a bit involved, but I'm writing a longer blog post about it.

    • Pl chevron_right

      Thibault Martin: TIL that GNOME has launched a fellowship program

      news.movim.eu / PlanetGnome • 4 days ago • 2 minutes

    When open source nonprofits ask for donations, one common answer is "I only want to fund code, I don't want to fund anything else." GNOME has created a Fellowship Program to fund direct work on GNOME, a program entirely funded by donations . This is a testament to the Foundation's maturity, as it becomes a direct contributor to the project it stewards.

    Let's take a step back to address the code-only argument. It is a misguided reaction, but I can see where its proponents are coming from. In the world of proprietary software, you pay to get your software. You don't realize that this bundles the marketing, accounting, legal, and even HR costs.

    In the open source world, everyone can see who contributes code and how that code is built and packaged to create a software solution. A lot of things are not shown in git commits though. A few of them are:

    • What did it take to create the Human Interface Guidelines to have a coherent suite of applications? How many designers had to meet, what research did they have to do, did they have to meet in person?
    • What did it take to create the Developer Documentation to onboard new developers, help them make their first steps, and turn them into bigger contributors over the years?
    • What did it take to build a website to advertize all the cool apps that follow the GNOME HIG ?
    • What did it take to set up the infrastructure the code lives on, and that builds the software we all love?

    GNOME, like many other open source projects, is first and foremost a community. This is a group of people with diverse backgrounds, diverse opinions, who try to find common ground to solve problems. They don't always agree on how to solve problems, nor necessarily on what even is a problem in the first place.

    The role of The GNOME Foundation is to provide a place to support its community. Its role is to help its contributors find common ground. Its role is to give them the tools and opportunities to do so.

    Some people still don't value this, and want The GNOME Foundation to be a vendor for GNOME. They want to fund developers to produce code , because that's a very visible metric.

    For them, and for everyone who's ever wanted to give back to GNOME without knowing how, The GNOME Foundation has created a Fellowship Program . It will directly fund a person to work on what few people want to do in their spare time: maintenance.

    Round one focuses on sustainability: improving tooling, build systems, test infrastructure, automation, documentation, developer productivity, and ongoing maintainability. We are not funding feature development: the goal is for each fellowship to leave the project in a more efficient and sustainable state.

    This is only fueled by our donations. If you want a direct pipeline between your money and GNOME development, this is it. Donate to GNOME , we can't afford not to have them when Big Tech has so much influence on our lives.