Sabtu, 24 Oktober 2026

RAID Calculator

RAID Calculator
Drive sizes
Usable capacity -
Fault tolerance -
Storage efficiency -
Usable Parity/mirror

Compare layouts

Same drives, different layouts. This is usually the decision that matters most.

Power, save & share

    RAID terms explained

    Here is a brief explanation of the terms used on this online RAID calculator.

    Striping

    Data is split into chunks and written across several drives at once. It is fast because every drive works in parallel, but nothing is stored twice, so losing one drive loses everything. This is RAID 0.

    Mirror

    The same data is written to two or more drives. If one dies, another still has a complete copy. Simple and safe, but you only get the space of one drive per mirror. This is RAID 1.

    Parity

    Extra data calculated from your files, like the answer to a sum. If one number goes missing, you can work it out from the rest. Parity lets the array recreate a failed drive without keeping a full copy, so it costs less space than mirroring.

    Single parity

    One drive's worth of space holds parity, spread across all drives. The array survives one failed drive. RAID 5 and RAIDZ1 work this way.

    Double parity

    Two drives' worth of parity, so any two drives can fail. That includes a second drive dying while the first is being replaced, which is when it is most likely. RAID 6 and RAIDZ2 work this way; RAIDZ3 adds a third.

    Striped mirrors

    Drives are paired into mirrors, then data is striped across the pairs. You get the speed of striping and the quick recovery of mirrors, but only half the raw space. This is RAID 10.

    Rebuild (resilver)

    After you replace a failed drive, the array recreates its data by reading the other drives. ZFS calls this a resilver. Until it finishes, the array has less protection than usual.

    ZFS vs. traditional RAID

    Traditional RAID, from a hardware card or Linux's mdadm, only sees blocks of data and cannot tell if a block has gone bad. ZFS is a filesystem and RAID manager in one. It checksums every block, so it spots silent corruption and repairs it from the redundant copy. It only rebuilds the space actually in use, and a read error usually costs one file rather than the whole array. In return, it likes plenty of RAM, and growing a pool is less flexible: adding a single drive to an existing RAIDZ only arrived in OpenZFS 2.3.

    URE and drive class

    A URE (unrecoverable read error) is a spot on a drive that cannot be read back. Manufacturers rate how often this can happen. Consumer drives are usually rated at 1 error per 10¹⁴ bits read (about 12.5 TB). NAS and enterprise drives are rated at 1 per 10¹⁵ (about 125 TB). A rebuild reads a lot of data, so the calculator uses this rating to estimate the chance of hitting an error mid-rebuild. These are spec-sheet worst cases; real drives often do better.

    How is the power draw estimated?

    Each drive type uses a typical average draw for a drive that is spinning or active but not under heavy load:

    • 3.5" HDD: 6.5 W
    • 2.5" HDD: 2.5 W
    • 2.5" SATA SSD: 2.0 W
    • NVMe SSD: 4.0 W

    The array total is that figure multiplied by the number of drives. The yearly figure assumes the drives run 24 hours a day, every day: watts × 8,760 hours ÷ 1,000 = kWh.

    It counts the drives only. The CPU, motherboard, fans and power supply losses add more, while spinning drives down when idle lowers it. Treat it as a ballpark for comparing layouts.

    Frequently Asked Questions

    Here are the answers to common questions you might have:

    Should I use RAID 5 or RAID 6?

    RAID 6 is the safer choice for arrays built with large modern drives (8TB and above). RAID 5 tolerates only one drive failure, and rebuilding after a failure requires reading every surviving drive in full. A single unreadable sector during that window can compromise the rebuild. RAID 6 adds a second parity block, so the array survives a second failure or read error during that window. The cost is one extra drive's worth of capacity. RAID 5 remains reasonable for small arrays of small drives or non-critical data.

    Is ZFS RAIDZ better than a ZFS mirror?

    Neither is universally better. RAIDZ (especially RAIDZ2) gives you more usable capacity from the same drives, while mirrors give faster resilvers, better random I/O performance, and simpler expansion, since you can grow a pool by adding another mirror pair. For most home NAS builds with 4 to 10 drives where capacity matters, RAIDZ2 is the common recommendation; for performance-sensitive workloads or pools you expect to expand gradually, mirrors are often the better fit.

    Is RAID a backup?

    No. RAID protects against drive hardware failure and nothing else. Accidental deletion, ransomware, file corruption, controller failure, theft, and fire all affect every drive in the array simultaneously. RAID keeps your system available when a drive dies; a backup lets you recover data you have lost. You need both, and the standard advice is the 3-2-1 rule: three copies of your data, on two different types of media, with one copy off-site.

    How much usable space do I get from RAID 5?

    RAID 5 gives you the capacity of all drives minus one, based on the smallest drive in the array. Four 4TB drives yield 12TB usable; six 8TB drives yield 40TB usable. Note that your operating system reports capacity in TiB (binary units), so 12TB will appear as roughly 10.9TiB. The space is not missing; it is a difference in units.

    Can I mix different drive sizes in RAID?

    Yes, but every drive in the array is treated as if it were the size of the smallest drive, and the extra capacity on larger drives sits unused. Mixing a 4TB drive into an array of 8TB drives effectively turns them all into 4TB drives. If you must mix sizes, replacing the smallest drive is usually the cheapest way to reclaim capacity. Some systems (like Unraid or Synology SHR) handle mixed sizes more gracefully than standard RAID.



    from It's FOSS https://ift.tt/hvFpglx
    via IFTTT

    Jumat, 23 Oktober 2026

    These Projects are Keeping X11 Dream Alive on Linux

    projects keeping x11 alive banner

    By now, you must know that mainstream Linux desktop environments, and by extension, distributions, are moving away from X11.

    If you don’t know what an X11 session is, it is a desktop session that uses the X Window System, typically through the X.Org Server (Xorg). The server handles graphical output and input communication between applications and the display, while other components manage windows and compositing.

    The newer, increasingly favored approach on Linux is a Wayland session.

    Wayland is a display protocol, and its compositor acts as the display server, handling graphical output, input, window management, and compositing.

    KDE has confirmed that Plasma 6.7 is the last release with a native X11 session, while GNOME has also removed its own X11 session. Of course, X11 applications can still run in Wayland sessions through the Xwayland compatibility layer.

    Though not everything is lost for people who prefer X11. Several projects are emerging to keep the experience alive, with some maintaining or forking the existing X.Org Server, while others go as far as rewriting an X11 server from scratch.

    This list covers eight of them, spread across desktops, X servers, and a layer that runs X11 apps on a Wayland compositor. Each one is open source and has shown development activity within the past few months.

    1. SonicDE

    sonicde

    SonicDE is a desktop that branches off KDE Plasma 6 and puts X11 first. It began in 2025 as a patched KWin/X11 called kwin-x11-improved. That grew into sonic-win, a window manager and compositor that keeps KWin/X11 going with code borrowed from KWin/Wayland and its own fixes.

    Beyond the window manager, SonicDE is forking the KDE pieces it builds on and stripping out Wayland-only code. A Vulkan backend is in progress, and the developers plan to keep X.Org Server compatibility going while that remains feasible.

    There's also conveniences, such as global hotkeys for push-to-talk and OBS recording toggles, and screen recording inside remote desktop apps like TeamViewer. Packages are available for Arch-based distributions, Artix, Manjaro, Gentoo, Void, and Slackware, among others.

    Install instructions and links to each distribution’s packages are on the installation page.

    2. Trinity Desktop Environment

    trinity desktop environment

    Trinity Desktop Environment, or TDE, keeps the KDE 3.5 codebase going as a desktop of its own. The project's goal is to preserve the look and feel of a traditional desktop while being lean and requiring modest hardware to run.

    Unlike KDE Plasma and GNOME, TDE continues to offer a traditional X11-based desktop environment rather than moving to Wayland. Its features include a built-in X11 compositor, with the project maintaining the components needed for its classic desktop experience.

    The R14.1.6 release, the sixth maintenance update in the R14.1.x series, was announced in April. It fixed window tiling for maximized windows, improved branding, and addressed several transparency problems. It also added a 3D border option for the Kicker panel and a "Go to Desktop" action in Konqueror.

    TDE can be installed on various Linux distributions and FreeBSD. You will find the latest packages on the official website.

    3. Wayback

    wayback gitlab repo
    📋
    This is alpha-quality software, and the interval between new releases is long.

    Wayback does not replace X11 clients or desktops. It replaces the layer underneath them.

    The project is a small Wayland compositor built with wlroots. It carries just the required Wayland functionality to run Xwayland in rootful mode, allowing an entire X11 desktop environment to run inside it.

    The aim is to make the traditional Xorg server binary unnecessary while retaining support for existing X11 desktops, particularly in Alpine Linux. The project is still experimental, so compatibility isn't guaranteed.

    Ariadne Conill of Alpine Linux started the project. It is MIT-licensed and hosted on freedesktop.org's GitLab instance.

    The remaining five entries are X servers or X server ports, ordered from the most mature to the least.

    4. XLibre

    xlibre on gentoo
    Sourced from Scott Alfter.

    XLibre is a community-maintained fork of X.Org Server that aims to keep X11 viable while continuing to develop the existing codebase. It also carries forward improvements that were never released in X.Org Server, including some features previously available only in Xwayland.

    The changes are practical. TearFree modesetting is enabled by default, while atomic modesetting is available as an option. XLibre also introduces Xnamespace, an extension designed to separate X clients, and supports seat management through seatd as an alternative to systemd-logind.

    The project also maintains CI builds for Linux, the BSDs, macOS, and Windows, although build coverage does not necessarily imply equal support across all these platforms.

    Suggested Read 📖: PeppermintOS is moving from Xorg to XLibre to avoid Wayland.

    5. Yserver

    0:00
    /0:10
    📋
    The project is quite early in the development cycle and has one main contributor.

    yserver is Jos Dehaes' ground-up X server rebuild in Rust, and the code is MIT-licensed.

    It does not try to reproduce everything Xorg does. Indirect GLX, the DDX driver interface, non-TrueColor visuals, and clients with swapped byte order are among the things it leaves out.

    Clients connect over Unix sockets by default, while TCP transport and XDMCP support are available as optional build features.

    Despite its narrower scope, yserver can already run complete MATE, Xfce, and Cinnamon desktop sessions. It has also been tested with window managers such as FVWM3, Window Maker, Openbox, i3, and Enlightenment.

    The project runs the X.Org X Test Suite to measure protocol compatibility, but development is ongoing and it is not intended to be a drop-in clone of Xorg.

    You can find the code for it on GitHub.

    6. XQuartz

    xquartz releases page

    Unlike the other projects here, XQuartz is not trying to preserve an X11 desktop on Linux or replace the Xorg server with a new implementation. It builds on X.Org's X Window System for macOS, allowing X11 apps to run alongside native Mac apps in the same desktop session.

    The latest stable release, 2.8.6, arrived in July 2026. It updated several bundled components to address older security vulnerabilities and fixed rendering issues affecting Apple Silicon Macs.

    It supports macOS 10.13 and later, and you can get it from the official website.

    7. Phoenix

    phoenix git page

    Phoenix is an X server built from scratch in Zig, not an Xorg fork, and it is licensed GPL-3.0-only. The idea is to build a simpler server than Xorg by supporting only a subset of the X11 protocol, with a focus on modern applications and graphics hardware.

    Most of its planned improvements concern security and graphics.

    Protocol messages are meant to be parsed automatically, applications are intended to be isolated from each other by default, and clipboard access is planned to be restricted to focused applications, with an option to restore Xorg-like behavior.

    Other goals include tear-free rendering, a built-in compositor, better multi-monitor support with different refresh rates, and HDR. In cases where features such as HDR need more than the existing X11 protocol offers, the project says it may extend the protocol.

    For now, Phoenix only runs nested inside an existing X server, where it can render GTK 3, GLX, EGL, and Vulkan applications with hardware acceleration. It remains under development and is not ready for everyday desktop use.

    The code is available on dec05eba's git server.

    8. Frame

    frame github repo

    Frame is an X server for x86_64 Linux written entirely in NASM assembly. It skips libc, Xlib, and other typical user-space dependencies, speaking to the X11 protocol directly and communicating with the kernel through DRM/KMS and evdev.

    Geir Isene created it for the CHasm desktop with the long-term goal of supporting the desktop alongside ordinary X11 clients. Right now, Frame can serve up to 128 clients at once and supports SHAPE, RANDR, XInput2, and MIT-SHM.

    It is released under the Unlicense, and its README credits Claude Code.

    The code is available on GitHub

    💬 Know some other projects that can be added to this list? Share them in the comment section.



    from It's FOSS https://ift.tt/EwgBG9c
    via IFTTT

    ArmSoM Sige7s Puts the RK3588S on a Raspberry Pi-Sized Board, and There's a Compute Module Too

    ArmSoM Sige7s

    If you've followed It's FOSS for a while, you probably have seen our previous coverage of ArmSoM devices. I reviewed the Sige7 a while back and came away impressed (cheeky headline and all). Earlier this year, we also covered the Sige6, the first Sige board to swap Rockchip for Allwinner.

    Now the Sige lineup is back on Rockchip with the Sige7s. So, what's changed?

    ArmSoM Sige7s

    Key Specifications

    • SoC: Rockchip RK3588S, 8nm, 4x Cortex-A76 @ 2.4GHz + 4x Cortex-A55 @ 1.8GHz
    • AI: 6 TOPS NPU (INT4/INT8/INT16)
    • RAM: up to 32GB LPDDR4/4X
    • Storage: removable eMMC module (16GB to 128GB) + microSD
    • Networking: Wi-Fi 6 + Bluetooth 5.0, Gigabit Ethernet with PoE support (add-on module)
    • 2x USB 3.0 + 2x USB 2.0
    • 1x MIPI CSI (up to 5MP camera)
    • CAN, SPI, PWM, 3x UART, 2x I2C, 6x ADC
    • RTC battery connector
    • Headphone out
    • Power and Maskrom buttons
    • 0°C to 80°C operating temperature
    • Size: 85 x 56 x 17mm, same footprint as a Raspberry Pi
    Sige7s Interface

    The Sige7s starts at $153 on ArmSoM's store.

    The "s" in the name comes from the chip. The RK3588S is the trimmed-down version of the RK3588 that powers the Sige7. You get the same CPU, the same Mali-G610 MP4 GPU, and the same 6 TOPS NPU. What you lose is peripheral bandwidth. There is no PCIe 3.0, one HDMI output instead of two, no HDMI input, and only one Gigabit Ethernet controller.

    In simpler words, the compute is the focus here, the I/O is not. If you want a Rockchip SBC fast NVMe drive or dual networking, this isn't the board for you. If you want RK3588-class power in a smaller package for less money, it is.

    ArmSoM Sige7s

    There are a few more indirect cost optimizations here for the users. Sige7s accepts a wide 5V to 23V input, so you aren't stuck with a specific USB-C power brick. It also uses a removable eMMC module, which means your precious storage isn't stuck to the board if you want to upgrade or reflash it on another machine.

    On the display side, there's HDMI 2.1 up to 8K@60fps, a DisplayPort 1.4 over USB-C, and a 2-lane MIPI DSI connector. The hardware video engine decodes 8K@60fps H.265/VP9 and encodes 8K@30fps, so it can double as a serious media box.

    ArmSoM Sige7s

    The 40-pin header is Raspberry Pi compatible, and ArmSoM says it works with Pi HATs, the Pi 7-inch display, the IMX219-based Pi camera, and Pi 4 cooling solutions. That's a good thing if you already have Pi accessories in your stock or if you want to expand the board.

    Prefer a Compute Module? Meet the CM7s

    ArmSoM CM7s

    Alongside the Sige7s, ArmSoM also offers the CM7s, a compute module built around the same RK3588S chip. I checked both spec pages, and the CPU, GPU, NPU, and video engine are identical. It's just a different form factor.

    In case you did not know, the compute module contains just the processor, memory, storage, and power management. There are no standard physical input/output ports like USB, HDMI, and Ethernet. Compute modules are more suitable in cases where they need to be embedded.

    The CM7s measures 55 x 40mm, pretty much the same size as the Raspberry Pi CM5. Not sure if you can put it into a CM5 carrier board, though.

    It's available with up to 32GB LPDDR4/4X RAM and up to 256GB eMMC. Through the 100-pin connectors, it exposes HDMI 2.1, DP 1.4, MIPI CSI/DSI, USB 3.0, PCIe 2.0/SATA, and the usual GPIO buses. ArmSoM has also committed to producing it until at least August 2034, which is reassuring if you're building a product around it.

    To get started, there's the CM7s-IO carrier board. It gives you HDMI, USB-C DisplayPort, 4x USB 3.0, Gigabit Ethernet, a 40-pin header, an M.2 M-key slot for NVMe SSDs, microSD, and MIPI camera and display connectors. Unlike the Sige7s, it runs on a 12V DC barrel jack.

    Pricing and Availability

    Both boards are available now from ArmSoM's official store, with AliExpress and Taobao listings as well.

    The Sige7s starts at $153. Wi-Fi antennas are sold separately, so add those to your cart.

    The CM7s starts at $179.

    If you're in the US, note that ArmSoM collects 25% of the product value as prepaid customs duty at checkout (listed as "sales tax"), so there's no surprise bill on delivery.

    If you just want a ready-to-use RK3588S computer, go for the Sige7s. If you're designing your own hardware or want an NVMe slot via the carrier board, the CM7s is the one.

    ArmSoM hardware might remind you of Banana Pi boards, that's because the two companies are known to work closely together, and the boards often share the same base.

    One more thing worth I have noticed. ArmSoM's documentation has improved considerably since I first tried their boards. That's a positive sign because new SBCs often struggle with the documentation and community.



    from It's FOSS https://ift.tt/T8pH2kR
    via IFTTT

    Kamis, 22 Oktober 2026

    Red Hat Funded a Report That Found a Quarter of Incoming Pull Requests May Be AI Slop

    lf research and red hat ai-themed banner

    LF Research is the Linux Foundation's research arm. It was set up in 2021 and publishes studies on how open source is built and used, drawing on surveys and project data.

    Its latest report, Navigating Open Source Software Development in the Generative AI Era, surveyed 234 contributors and maintainers on how generative AI is affecting the way open source gets made.

    The survey estimates that about 25% of incoming pull requests are low-quality AI slop, with the estimate climbing to 31% on larger projects.

    Red Hat sponsored the report, with additional contributions from OpenSSF, LF AI & Data, and Futurewei.

    The findings

    Large projects, the ones with more than 50 contributors, are affected the most.

    Among their maintainers, 69% report more incoming contributions, against 59% across all maintainers, and 64% say reviews now take longer. Burnout is their top concern at 63%, narrowly ahead of contribution quality at 60%.

    You will also find that policies have not caught up to the AI-assisted coding and vulnerability reporting trend.

    Of the 119 respondents who answered the question, 35% said their project has a formal policy permitting AI use. Another 32% have none and no plans for one, 23% plan to write one, and 10% ban AI contributions outright.

    You might remember that some projects, like LLVM, allow AI-generated code with conditions. Separately, 26% of projects have no way of verifying AI-assisted contributions at all.

    The report calls on contributors to give effort to written policies, disclosure of AI use, and testing and documentation.

    Interestingly, AI does seem to save developers' time. Respondents estimate that code authoring takes 52% less time on average, while on more complex tasks, 21% said the work took longer with AI.

    Most maintainers (71%) say AI makes it easier for newcomers to start contributing. Just over half (53%) say it has not improved community trust, while only 13% say it has.

    Some caveats do apply. 📝

    the methodology followed by lf research for this report

    Respondents were recruited through Linux Foundation newsletters and social channels, plus partner channels that include Red Hat. As for the 25% slop figure, it is an estimate from 111 respondents, not a measured count.

    That sounds fair, but disclosure is mostly left to individual choice right now, and a quarter of projects have no way to check anything. It only works if the people sending slop make an effort to do it.

    And as we have already seen time and again, the ones sending slop rarely bother. 🤷


    Suggested Read 📖: Save up to 40% on Kubernetes security certifications.



    from It's FOSS https://ift.tt/U04mBDw
    via IFTTT

    This Newly Proposed Linux Filesystem Can Fix Corrupted Data

    beamfs linux and storage-themed banner

    The kernel's filesystem mailing list has received an 18-patch proposal this week from Aurelien Desbrieres, the creator of BeamFS. It takes the place of FTRFS, an earlier filesystem he had proposed back in April.

    Aurelien says he used Anthropic's Claude to write the code, the tool that checks the patches, and the cover letter.

    He also points out that every patch carries an Assisted-by tag. You might remember that is the disclosure the kernel's AI coding assistants policy asks for. The same policy keeps the human submitter responsible for the code.

    How does it fix data?

    Filesystems that can repair damage, like Btrfs and ZFS, usually do it by falling back on a spare copy of the data. BeamFS skips that and stores Reed-Solomon error-correcting codes inside every block.

    Every read gets checked against those codes, and small amounts of damage are corrected before the data reaches the application. If the filesystem can tell the damage is beyond repair, the read fails with an error instead of returning the wrong bytes.

    The idea started with satellite computers. They keep data on a single drive and cannot fit a second copy. The same case is made for radiotherapy rooms.

    Neutrons from treatment machines can flip bits in the computers there, including the ones handling imaging and records. Aurelien argues a silently wrong byte does more damage in that setting than a failed read.

    BeamFS has not been tested in a real radiation environment yet. The tests done so far simulated the damage by flipping single bits in data as it was read on virtual machines and USB flash drives.

    In his technical report, ext4 and ext3 returned wrong data without any error, while Btrfs refused to read the file. BeamFS returned the correct file every time except once, when a flip hit a pointer to the file’s data and it refused the read.

    Do keep in mind that the comparison is uneven. Each filesystem received a different number of flips, and the report makes it clear that it is not a ranking.

    Is it close to landing?

    Nope, this is a request for comments (RFC). Aurelien is asking for feedback, not calling for a merge, and he has two questions for the maintainers.

    The first is whether it should be a separate filesystem or be proposed for an existing one.

    The second is the journal, the log other filesystems use to recover from crashes. BeamFS lacks one and relies on its fsck tool after an unclean shutdown. Aurelien asks whether it has to come before further review or can be submitted afterward.

    So far, the only reply in the thread is about where the MAINTAINERS entry sits alphabetically.

    The project's README has a warning of its own. It lists bugs that can lose data, open security holes, and crash the kernel, advising against trusting the code with anything important.



    from It's FOSS https://ift.tt/H3sqBYT
    via IFTTT

    FOSS Weekly #26.43: Kernel 7.3, Non-Linux OS, de-Googled Phone, DuxOS, Podcasts, De-bloating TVs, KDE Dock and More

    FOSS Weekly 26.43

    Steam’s Linux client is going 64-bit and containerized. Running the client inside Steam Runtime containers, like its games already do, should make it behave more consistently across different distros.

    Ubuntu 26.10 is out now. This interim release completes the rustification of core utilities, adds Sequoia PGP to the main archive, and brings Linux 7.3 with Snapdragon X2 Elite support and better GPU memory handling.

    Fedora 45 release is delayed, and it should now be released on 30th October.

    CutefishOS is making a comeback with a completely rebuilt desktop written using Anthropic’s Fable and Opus AI models. Ships with its own Wayland compositor and graphics library, skips Qt and GTK entirely, and launches apps quickly.

    Dux Labs is the new name for Dank Linux and its Wayland suite, now that DMS has grown beyond a single product. The rebrand coincides with DMS 2.0, which adds Material 3 design, a new file manager, and widget support.

    🧠 What We’re Thinking About

    A €115 billion price tag for Europe’s cloud independence sounds steep until you note who paid for the study. Amazon, Google, and Meta funded the report through their lobby group, warning against rules that would dilute their market power.

    🛍️ Get certified for less

    The Linux Foundation's Kubernetes Security Certifications bundle is up to 40% off until October 23. That's tomorrow. If you are looking for a career in DevOps, you can purchase the exam for less and schedule it within a year of time. There is also a 3-day money-back guarantee.

    🧮 Linux Tips, Tutorials, and Learnings

    Our newly-updated podcast roundup covers 15 Linux shows active in 2026, from news digests like This Week in Linux to community shows like mintCast. Which ones are your favorites?

    Want to dress up your Linux desktop for Halloween? At least Hyprland users can follow this customization tutorial that covers everything from the Gothic theme to wallpapers. Grab the config files from GitHub and turn your desktop into something out of a nightmare. 🎃👻

    Looking beyond Linux, here are nine open source operating systems that cover wildly different purposes. Haiku mimics BeOS for responsive desktops, Redox pursues pure-Rust design, FreeBSD dominates servers, and ReactOS attempts Windows compatibility from scratch.

    And if you are in a mood to test your Linux command line knowledge, challenge yourself by attempting this CTF.

    👷 Homelab and Hardware Corner

    Android TV owners are using AI to strip ads and bloat straight from their hardware. I have to accept that this is the most amusing usage of AI I have seen so far.

    There is a new de-googled phone worth a look for privacy enthusiasts. It's 4 inches in size and has both a keyboard and a touchscreen. You may also want to take a look at MAKERphone 2.0 if such devices interest you.

    ✨ Apps and Projects Highlights

    Here's a terminal text editor that you can use with a mouse. It's like VS Code's terminal equivalent.

    📽️ Videos for You

    If you are a KDE user, you should see this awesome Dock in action in the latest video.

    💡 Quick Handy Tip

    0:00
    /0:21

    On KDE Plasma, if you have Filelight installed, then you can quickly analyze disk usage for any directory right from Konsole. Just right-click any folder or empty space in the terminal, select "Open With", and choose "Filelight" to launch a visual breakdown of your files.

    🎋 Fun in the FOSSverse

    I have redesigned the Quizzes page. You can now see most of the quizzes neatly displayed in categories. Over 140 crosswords, quizzes, and puzzles to enjoy.

    Are you willing to make that sacrifice? 🤔

    ditch proprietary software

    🗓️ Tech Trivia: Ubuntu first arrived on October 20, 2004, with the 4.10 release, nicknamed Warty Warthog. Since then, it has stuck to a standardized rhythm, putting out a new release every six months and an LTS version every two years.

    🧑‍🤝‍🧑 From the Community: Pro FOSSer Mikael is looking for a printer that is compatible with Linux. Got any suggestions for him? 🖨️❓



    from It's FOSS https://ift.tt/IdQUfBT
    via IFTTT

    Terminal Text Editor: Like VS Code But in Linux Terminal

    Terminal Text Editor

    I spend a lot of time in the terminal. Whether it is writing scripts, editing configuration files, or managing remote servers, the terminal remains the place where I get most of my work done. But when a project becomes slightly complex, I often find myself reaching for the comfort of a graphical code editor like Zed.

    I'll be honest, while I can appreciate why people love tools like Vim and Neovim, learning a modal editor has always felt like more of a commitment than I was willing to make.

    My editing needs are fairly straightforward, and spending hours memorizing keybindings, configuring plugins, and building a workflow from scratch never felt like a worthwhile investment for me.

    That's why TTT caught my attention. The project describes itself as a real alternative to VS Code, Zed, and Sublime Text that runs entirely inside the terminal.

    ✋
    Like most of the new open source software, TTT is also developed with the help of AI assistants.

    Installing TTT

    On Linux, to install TTT, you can use the official installer script. That's fashion these days. No package, just an installer script curled right into your system.

    curl -sSfL https://raw.githubusercontent.com/eugenioenko/ttt/main/install.sh | sh
    

    This will install the binary in ~/.local/bin. To run it, open your favorite terminal and use the command:

    ttt
    

    There are also prebuilt binaries available to download so that you can place it in a folder of your choice and use it in portable mode.

    TTT features I liked

    Instead of trying to emulate traditional terminal editors, it aims to provide a modern, GUI-like editing experience in the terminal application with virtually no configuration required.

    Sure, not all of these features might be unique, but they are good to have in an editor.

    Syntax Highlighting

    TTT uses textmate-go for syntax highlighting, a Go implementation of Microsoft's TextMate engine that powers syntax highlighting in VS Code. It claims to support more than 120 languages out of the box, giving it a surprisingly mature editing experience for a terminal-based application.

    Syntax Highlighting in TTT shown using a sample C file.
    Syntax Highlighting

    Multi-Cursor Editing

    Multi-cursor editing is one of those features I started appreciating after spending some time with Helix. It's something I now instinctively look for in any editor.

    Thankfully, TTT ships with multi-cursor support out of the box, so there's no need to install plugins or configure anything before getting started.

    The workflow feels familiar if you've used modern editors before, like Sublime Text.

    Pressing Ctrl+D selects the next occurrence of the highlighted text, while Alt+Click lets you place additional cursors exactly where you need them.

    Multi-Cursor Editing

    Mouse Support

    Many terminal editors advertise mouse support, but often that simply means you can click around and scroll. TTT goes much further than that.

    The mouse interactions felt surprisingly close to what I'd expect from a graphical editor rather than a typical terminal application.

    You can click to position the cursor, drag to select text, and right-click to access context menus.

    0:00
    /0:30

    Mouse Support in TTT

    The latter ended up being my favorite part because the menu isn't just a generic list of actions. Depending on where you click, TTT presents relevant options, making the whole experience feel far more polished and GUI-like than most terminal editors I've tried.

    LSP and Auto Completion

    A code editor doesn't feel complete these days without intelligent auto-completion, and TTT checks that box through Language Server Protocol (LSP) support.

    Getting it up and running is fairly straightforward as you only need to install the language server for the programming language you work with.

    The project also maintains a dedicated guide covering language server setup for a wide range of languages, which can save some trial and error during the initial configuration.

    Once configured, you get the kind of code completion and language-aware features you'd expect from a modern editor, but without leaving the terminal.

    LSP Autocompletion

    Multi-folder Workspaces

    Multi-folder workspaces allow you to group related folders into a single workspace and treat them as one project, much like VS Code's multi-root workspaces.

    What makes this even more useful is that the workspace can be saved to a workspace.ttt file and reopened later with the exact same setup. So instead of manually opening the same collection of directories every time, you can simply load the workspace and continue where you left off.

    For example, I have this customization.ttt file that has the content:

    {
      "folders": [
        { "path": "/home/itsfoss/Projects/text-script-files/" },
        { "path": "/home/itsfoss/Projects/public-dot-files/" },
        { "path": "/home/itsfoss/Projects/desktop-customization" }
      ]
    }
    

    Now, I can always open this workspace by using the command:

    ttt --workspace ~/Projects/customization.ttt
    

    You don't need to manually create this file since you can add location to a workspace and later save it all via File -> Save Workspace As option.

    0:00
    /0:41

    Multifolder Workspaces

    Modern Search with Ripgrep

    TTT uses ripgrep under the hood, which is already a favorite among developers thanks to its speed and ability to handle large projects without feeling sluggish.

    In practice, this means you get fast, project-wide search capabilities directly inside the editor.

    Combined with shortcuts like the Ctrl+K F for workspace search and Ctrl+K R for search and replace, it feels much closer to the experience you'd expect from a modern GUI editor than a typical terminal-based tool.

    Search in TTT

    💡
    You need to have ripgrep installed on your system.

    Git Integration

    TTT provides a dedicated Changes panel where you can stage, unstage, discard, commit, pull, push, and sync repositories without dropping back to the command line.

    The built-in diff viewer is particularly nice to work with because it combines Git diffs with syntax highlighting, making code changes easier to read.

    The Git gutter indicators and inline blame information help provide context while editing.

    If you're working with multiple repositories in a workspace, TTT automatically groups changes by repository, which keeps things organized when juggling several projects at once.

    0:00
    /0:33

    Git Integration

    Integrated Terminal

    You may find it funny that one of my favorite features in a terminal-based editor is... another terminal. But in practice, I found it incredibly useful.

    Whenever I needed to run a command, I didn't have to open a split terminal in my terminal emulator or switch to another tab. Everything stayed inside TTT, which helps maintain focus on the task at hand.

    TTT's integrated terminal is a full terminal emulator rather than a basic command prompt. It supports multiple terminal tabs, true-color rendering, scrollback, and can be toggled between panel and fullscreen modes with keyboard shortcuts.

    For a project that aims to bring a GUI-like experience into the terminal, this feature fits perfectly, eliminating one more reason to leave the editor while working.

    0:00
    /0:41

    Integrated Terminal

    Plugins

    TTT already comes with many of the features I normally install plugins for in other editors. But the more I explored it, the more I appreciated the approach.

    TTT supports Lua-based plugins that can add commands, panels, and keybindings, allowing you to extend the editor without turning it into a configuration project.

    Plugins run inside a sandboxed environment and must explicitly request permissions to approve each plugin's capabilities.

    To add even more convenience, you can install plugins through a dedicated panel within the TUI.

    You may read more about the plugins in their official documentation.

    Plugins in TTT

    Theming

    TTT ships with a decent collection of built-in themes, including popular options like Dracula, Monokai, etc., making it easy to find something comfortable without downloading anything extra.

    The built-in theme picker offers live previews as you browse themes, and you can customize virtually every aspect of the interface through JSON files, from syntax highlighting and diff colors to the sidebar, status bar, and even terminal colors.

    Themes in TTT

    Wrapping Up

    After spending some time with TTT, my biggest takeaway isn't that it's a great terminal editor. It's that this thing often doesn't feel like a terminal editor at all. In many ways, it feels like a full-blown GUI application that just happens to live inside a terminal window.

    Now, I don't know how many of you will actually approve of that direction. The Linux and terminal communities have long maintained a clear distinction between TUIs and GUIs, and plenty of users prefer terminal applications precisely because they don't try to mimic desktop software. TTT deliberately blurs that line. Whether that's a good thing or not will ultimately depend on what you want from a terminal editor.

    I found TTT's approach refreshing. It takes many of the conveniences people expect from modern GUI editors and brings them into the terminal with surprisingly very few compromises. If that idea sounds appealing, TTT is absolutely worth a look.

    By the way, TTT is not the only editor of this kind. We have covered several other terminal editors that are easy to use since they provide terminal user interfaces that can be used with a mouse. If you are not allergic to Microsoft, their open source Edit editor is also worth a look.

    I welcome your comments on TTT and other terminal based text editors you prefer.



    from It's FOSS https://ift.tt/npNGybw
    via IFTTT