Language Selection

English French German Italian Portuguese Spanish

Linux Has Landed On Mars

Filed under
GNU
Linux
Sci/Tech

NASA has landed a new rover called Perseverance on Mars. It has it's own miniature helicopter named Ingenuity that can take off, navigate, and land on Mars without human intervention. Ingenuity runs a custom Linux-based operating system, Linux has now reached Mars.

Read more

The Perseverance Mars rover just took Linux to another planet

  • The Perseverance Mars rover just took Linux to another planet

    The landing of the Perseverance rover on Mars was not just a victory for science, but also for open source software, the team behind the project has revealed.

    In its bid to use software that was “safe and proven”, NASA turned to Linux and open source. “This the first time we’ll be flying Linux on Mars,” said Tim Canham, Mars Helicopter Operations Lead at NASA’s Jet Propulsion Laboratory (JPL) in a discussion with IEEE Spectrum.

    Without going into too much detail, Canham mentioned that the flight software framework NASA is using on the tiny helicopter dubbed Ingenuity, that’s tucked under the Perseverance Mars rover, was originally developed for miniature satellites called CubeSats.

Linux has made it to Mars

  • Linux has made it to Mars

    Yesterday, NASA landed a rover named Perseverance on Mars. I, along with 2 million other people, watched the landing happen live on YouTube. It was beautiful. I mean, here’s this little robot dude that’s traveled millions and millions of miles through the barrenness of space, and now it’s just hanging out on Mars taking pics and scientific samples! (Perseverance joins older sibling Curiosity on the surface of the Red Planet. Hope they have a nice time together!)

    In any case, Perseverance didn’t traverse the vastness of space alone. Ingenuity, a tiny helicopter, tagged along for the ride. As it’s primarily a technology demonstration, Ingenuity’s destiny is to attempt the first powered flight on any planet other than Earth and to hopefully be the blueprint for future Mars missions. It’s also running on Linux.

To infinity and beyond: Linux and open-source goes to Mars

  • To infinity and beyond: Linux and open-source goes to Mars

    Perseverance hit Mars' atmosphere at almost 12,000 miles per hour (19,312 kilometers per hour) and a mere seven minutes later NASA landed its latest Mars rover softly and safely. Onboard the one-ton mobile science lab is its tiny flying companion, the drone helicopter Ingenuity. If all goes well, the four-pound (1.8 kilograms) Ingenuity will be the first vehicle to ever fly on another world. At 11-light minutes from Earth, no one will fly the dual-propped Ingenuity with a drone controller. Instead, it will fly itself using a combination of Linux and a NASA-built program based on the Jet Propulsion Laboratory's (JPL) open-source F´ (pronounced F prime) framework.

Linux Is Now on Mars, Thanks to NASA's Perseverance Rover

  • Linux Is Now on Mars, Thanks to NASA's Perseverance Rover

    When NASA’s Perseverance rover landed on Mars this week, it also brought the Linux operating system to the Red Planet.

    The tidbit was mentioned in an interview NASA software engineer Tim Canham gave to IEEE Spectrum. The helicopter-like drone on board the Perseverance rover uses a Linux-powered software framework the space agency open-sourced a few years ago. “This the first time we’ll be flying Linux on Mars. We’re actually running on a Linux operating system,” Canham said.

    It also might be the first time NASA has brought a Linux-based device to Mars. “There isn’t a previous use of Linux that I’m aware of, definitely on the previous rovers,” Canham told PCMag in an email.

Now in Slashdot

  • Linux Is Now on Mars, Thanks to NASA's Perseverance Rover

    The article also notes that the helicopter-like drone Ingenuity "was built using off-the-shelf parts, including Qualcomm's Snapdragon 801 processor, a smartphone chip."

    "Ingenuity is purely a technology demonstration," notes ZDNet. "It's not designed to support the Perseverance mission, which is searching for signs of ancient life and collecting rock and dirt samples for later missions to return to Earth. Its mission is to show that it's possible to fly on Mars using commercial off-the-shelf hardware and open-source software."

Linux lands on Mars – A victory for open-source

  • Linux lands on Mars – A victory for open-source

    In one of humankind’s historical moments, Linux-powered Perseverance Mars Rover has made a successful landing on Mars. Its landing software is powered by Linux – and open-source software that has been touted for its safety.

    Tim Canham mentioned the importance of Linux in the Perseverance Mars Rover success to Mars. In discussion with IEEE Spectrum, the Mars Helicopter Operations Lead at NASA’s Propulsion Laboratory said that “This is the first time we’ll be flying Linux on Mars.” He also touted how it was important for the team to use a proven and safe.

    The NASA expert was also not shy away from saying that, “It’s kind of an open-source victory.”

    The live telecast of the Perseverance Mars Rover making it to the land was watched by 2 million people on YouTube. The whole scene was mesmerizing and beautiful.

Linux flies on Mars onboard Snapdragon-powered Ingenuity drone

  • Linux flies on Mars onboard Snapdragon-powered Ingenuity drone

    There was a great deal of celebration at NASA and around the world when the Perseverance rover safely landed on the surface of Mars. That historic moment, however, carries a few firsts for a lot of things, and not just for space science alone. While the rolling rover is already important in itself, its companion helicopter drone is just as significant as it is the first time NASA used the open source Linux operating system on Mars, opening up the possibilities for tech demos like it in the future.

    Ingenuity, Perseverance’s flying companion, marks a couple of first things for NASA and Mars missions. It is the first aircraft to fly on Mars, for one, contending with different levels of gravity and atmospheric conditions from those of earth. It is also the first of its kind to be built from off-the-shelf parts, both hardware and software.

    The Ingenuity helicopter drone runs on a box powered by a Qualcomm Snapdragon 801, an older chipset that is apparently space-worthy and newer than the boards NASA has inside its rovers. Other parts that make up the drone were also sourced from easily accessible consumer hardware.

  • 2021 is the year of Linux on Mars

    Perseverance, sometime it will be the year of the desktop on Earth

    When NASA's Perseverance rover landed on Mars this week, it also brought the Linux operating system to the Red Planet.

    NASA software engineer Tim Canham said the helicopter-like drone on board the Perseverance rover uses a Linux-powered software framework the space agency open-sourced a few years ago.

    "This the first time we'll be flying Linux on Mars. We're actually running on a Linux operating system," Canham said.

Linux lands on Mars with Perseverance and Ingenuity <ul> <li><h

  • Linux lands on Mars with Perseverance and Ingenuity

    Here is your morning dose of miscellaneous Linux news. Not gaming but still very cool - Linux has officially landed on Mars with the Perseverance Rover. Before we've been able to hit that mythical year of the Linux desktop, heck before Wayland has even been able to replace X11 on Linux desktops, we have now managed to blast Linux to another planet far away.

    If you're not even the slightest space nerd like me you might be a bit confused, NASA just recently landed the Perseverance Rover on the red planet. That's cool by itself but Perseverance came with a rather fancy little Helicopter named Ingenuity, which according to NASA is "the first aircraft humanity has sent to another planet to attempt powered, controlled flight".

LINUX IN SPAAACE!

  • LINUX IN SPAAACE!

    One of the coolest parts of NASA's new rover mission is it's helicoper. Marking the first powered flight on another world. What's got me so excited about all this, though? This flying science machine is powered by LINUX!

Not Just Perseverance, Linux Is On Mars

  • Not Just Perseverance, Linux Is On Mars Too With NASA's Recent Success

    NASA’s Perseverance landed on the surface of Mars earlier this week amid appreciation from the whole world. The achievement was monumental after all, the small rover travelled to a distant planet that can soon be the next 'home' for humans. However, it wasn’t the only man-made thing in doing so.

    The now-renowned rover is accompanied by a tiny helicopter named Ingenuity, which is set to take the first ever flight on a planet other than Earth soon. Though it hasn't got a lot of coverage, but interestingly enough, the autonomous drone is powered by a Linux system.

Perseverance Rover Marks Linux’s Journey From Earth To Mars

  • Perseverance Rover Marks Linux’s Journey From Earth To Mars

    Another day, another open-source/Linux news but this one’s special. On 30th July 2020, the Perseverance rover designed by NASA took off to Mars to learn more about the Red Planet’s secrets.

    Fast forward to this day; the rover has finally landed. While this is a massive leap in space exploration, it’s also a huge win for the Linux community. That’s because something special resides under the rover’s belly. It’s called Ingenuity, a little helicopter that’ll be the first aircraft to fly on Mars.

NASA’s Martian helicopter runs Linux

  • NASA’s Martian helicopter runs Linux

    The semi-autonomous Ingenuity drone copter that will launch soon from NASA’s Perseverance rover runs open source Linux on a Snapdragon 801 along with components from Sparkfun.

    Like other NASA rovers, the Perseverance rover that successfully landed last week on Mars’ Jezero Crater runs on Wind River’s VxWorks RTOS. Yet tucked underneath the SUV-sized rover is an autonomous mini-helicopter called Ingenuity that runs Linux. The debut of Linux on Mars was revealed on Feb. 17 by Tim Canham, Mars Helicopter Operations Lead at NASA’s Jet Propulsion Laboratory (JPL) in an interview with IEEE Spectrum.

MARS helicopter “Ingenuity” runs GNU Linux :)

Comment viewing options

Select your preferred way to display the comments and click "Save settings" to activate your changes.

More in Tux Machines

Now you can make video calls on a PinePhone (but it’s very much a work in progress)

When the PinePhone began shipping to early adopters, it had all the hardware you’d expect from a smartphone, but it lacked the software needed to make some of that hardware work. If you were one of the first people to get your hands on a PinePhone, you had a Linux-friendly phone with a camera that couldn’t be used to take pictures or record video. But over time kernel and app developers got the phone’s front and rear cameras working, and now most Linux distributions for the PinePhone allow you to take pictures (of mediocre quality). One thing you couldn’t do until recently though? Video calls. But now it looks like that’s possible too… soft of. The process looks rather painful at the moment, but it should get better over time. Read more Also: Plasma Mobile tarball release: bugfixes and new releases

A warning about 5.12-rc1

  • A warning about 5.12-rc1
    Hey peeps - some of you may have already noticed that in my public git
    tree, the "v5.12-rc1" tag has magically been renamed to
    "v5.12-rc1-dontuse". It's still the same object, it still says
    "v5.12-rc1" internally, and it is still is signed by me, but the
    user-visible name of the tag has changed.
    
    
    
    
    The reason is fairly straightforward: this merge window, we had a very
    innocuous code cleanup and simplification that raised no red flags at
    all, but had a subtle and very nasty bug in it: swap files stopped
    working right.  And they stopped working in a particularly bad way:
    the offset of the start of the swap file was lost.
    
    
    
    
    Swapping still happened, but it happened to the wrong part of the
    filesystem, with the obvious catastrophic end results.
    
    
    
    
    Now, the good news is even if you do use swap (and hey, that's nowhere
    near as common as it used to be), most people don't use a swap *file*,
    but a separate swap *partition*. And the bug in question really only
    happens for when you have a regular filesystem, and put a file on it
    as a swap.
    
    
    
    
    And, as far as I know, all the normal distributions set things up with
    swap partitions, not files, because honestly, swapfiles tend to be
    slower and have various other complexity issues.
    
    
    
    
    The bad news is that the reason we support swapfiles in the first
    place is that they do end up having some flexibility advantages, and
    so some people do use them for that reason. If so, do not use rc1.
    Thus the renaming of the tag.
    
    
    
    
    Yes, this is very unfortunate, but it really wasn't a very obvious
    bug, and it didn't even show up in normal testing, exactly because
    swapfiles just aren't normal. So I'm not blaming the developers in
    question, and it also wasn't due to the odd timing of the merge
    window, it was just simply an unusually nasty bug that did get caught
    and is fixed in the current tree.
    
    
    
    
    But I want everybody to be aware of because _if_ it bites you, it
    bites you hard, and you can end up with a filesystem that is
    essentially overwritten by random swap data. This is what we in the
    industry call "double ungood".
    
    
    
    
    Now, there's a couple of additional reasons for me writing this note
    other than just "don't run 5.12-rc1 if you use a swapfile". Because
    it's more than just "ok, we all know the merge window is when all the
    new scary code gets merged, and rc1 can be a bit scary and not work
    for everybody". Yes, rc1 tends to be buggier than later rc's, we are
    all used to that, but honestly, most of the time the bugs are much
    smaller annoyances than this time.
    
    
    
    
    And in fact, most of our rc1 releases have been so solid over the
    years that people may have forgotten that "yeah, this is all the new
    code that can have nasty bugs in it".
    
    
    
    
    One additional reason for this note is that I want to not just warn
    people to not run this if you have a swapfile - even if you are
    personally not impacted (like I am, and probably most people are -
    swap partitions all around) - I want to make sure that nobody starts
    new topic branches using that 5.12-rc1 tag. I know a few developers
    tend to go "Ok, rc1 is out, I got all my development work into this
    merge window, I will now fast-forward to rc1 and use that as a base
    for the next release". Don't do it this time. It may work perfectly
    well for you because you have the common partition setup, but it can
    end up being a horrible base for anybody else that might end up
    bisecting into that area.
    
    
    
    
    And the *final* reason I want to just note this is a purely git
    process one: if you already pulled my git tree, you will have that
    "v5.12-rc1" tag, and the fact that it no longer exists in my public
    tree under that name changes nothing at all for you. Git is
    distributed, and me removing that tag and replacing it with another
    name doesn't magically remove it from other copies unless you have
    special mirroring code.
    
    
    
    
    So if you have a kernel git tree (and I'm here assuming "origin"
    points to my trees), and you do
    
    
    
    
         git fetch --tags origin
    
    
    
    
    you _will_ now see the new "v5.12-rc1-dontuse" tag. But git won't
    remove the old v5.12-rc1 tag, because while git will see that it is
    not upstream, git will just assume that that simply means that it's
    your own local tag. Tags, unlike branch names, are a global namespace
    in git.
    
    
    
    
    So you should additionally do a "git tag -d v5.12-rc1" to actually get
    rid of the original tag name.
    
    
    
    
    Of course, having the old tag doesn't really do anything bad, so this
    git process thing is entirely up to you. As long as you don't _use_
    v5.12-rc1 for anything, having the tag around won't really matter, and
    having both 'v5.12-rc1' _and_ 'v5.12-rc1-dontuse' doesn't hurt
    anything either, and seeing both is hopefully already sufficient
    warning of "let's not use that then".
    
    
    
    
    Sorry for this mess,
                 Linus
    
    
    
    
    
  • A warning about 5.12-rc1

    Linus Torvalds has sent out a note telling people not to install the recent 5.12-rc1 development kernel; this is especially true for anybody running with swap files. "But I want everybody to be aware of because _if_ it bites you, it bites you hard, and you can end up with a filesystem that is essentially overwritten by random swap data. This is what we in the industry call 'double ungood'." Additionally, he is asking maintainers to not start branches from 5.12-rc1 to avoid future situations where people land in the buggy code while bisecting problems.

  •  
  • Linux 5.12-rc2 Likely Coming Early Due To That Nasty File-System Corruption Bug

    Linus Torvalds has now warned developers over using Linux 5.12-rc1 as a basis for their future branches and is looking to release 5.12-rc2 ahead of schedule as a result of that problematic file-system corruption bug stemming from a swap file bug. 

Games: Godot, Artifact, Loop Hero, and Urtuk: The Desolation

  • Godot Showcase - Primal Light developer interview

    Welcome to the fourth developer interview following the introduction of the Godot Showcase page! This week, we are interviewing the studio Fat Gem about their first game Primal Light.

  • Valve gives up on Artifact setting it free with Artifact Classic and Artifact Foundry | GamingOnLinux

    Valve's Dota themed card game Artifact has now well and truly failed, as they've now stopped the 2.0 redevelopment which is now named Artifact Foundry with the original as Artifact Classic and both now free to play. In a post titled "The Future of Artifact", Valve mentioned how the player count fell off dramatically and it was pretty much dead shortly after being released. Even though the big 2.0 revamp was far along in development, they've now formally and totally shelved it as they "haven't managed to get the active player numbers to a level that justifies further development at this time".

  • Loop Hero is out now and I'm going to need help to tear myself away from it | GamingOnLinux

    Loop Hero, probably the only titles I've pre-ordered in the last few years is officially out now and I really will need some help to pull myself away from running just one more loop. It's such a strange and beautifully intoxicating mix of genres. For each loop through you're placed into a world full of nothing but a path and it's up to you to build up the world each time. You do this through your deck of cards, while the hero automatically loops around the path and fights enemies along the way without your input. Even though you don't have direct control, there's quite a lot of strategy involved in it.

  • Dark low-fantasy tactical survival RPG 'Urtuk: The Desolation' is out now | GamingOnLinux

    Urtuk: The Desolation from David Kaleta presents you with a dark world in a low-fantasy settings where you guide a team of survivors through a ruined world. Note: key provided by the developer. Hitting nearly one thousand user reviews and a Very Positive rating on Steam overall, Urtuk: The Desolation seems to have managed to hit a sweet spot. Giving you tough turn-based combat, with a character progression system that sees you extracting skills and traits from fallen enemies. It's a bit of a gross world and the main character, Urtuk, is an escaped subject of experimentation with a severe mutation and worsening health. The idea is to eventually find a cure but getting there will be tough.

today's howtos

  • How to find duplicate files in Linux? Help is here with the fdupes command! - Webleit.info

    Fdupes is a command line tool that allows you to find all duplicate files through the console. The advantage over using graphical tools like fslint is of course the speed. At the end of the day, there is nothing faster and more convenient than the Linux console. Why should we look for duplicate files in Linux? No matter what operating system you use sooner or later, your computer will contain many files of different sizes, and if you’re not careful enough, repeating them can cost you disk space that you need. For example, you inadvertently downloaded the same ultra HD movie with 40 giga bytes twice.

  • How to Install Moodle with Nginx and Let's Encrypt SSL on Ubuntu 20.04

    Moodle is a free and open-source Learning Management System written in PHP. It provides a way for tutors and instructors to create courses for their students or learners. Moodle provides a robust and secure integrated system and comes with a custom dashboard that helps users to access current, past or future courses, as well as review pending work. It is used by many schools, universities, and organizations across the globe and provides a better learning experience. It provides a rich set of features including, wiki, grading, assignment submission, online quizzes, discussion boards, and more. In this tutorial, we will show you how to install Moodle with Nginx web server and Let's Encrypt SSL on Ubuntu 20.04.

  • Install WordPress Automatically on Ubuntu 20.04 using WordOps

    WordOps is a simple tool that provides the ability to deploy WordPress sites from the command line using an optimized LEMP stack. The LEMP software stack consists of a group of software that describes a Linux Operating System, an Nginx web server (pronounced engine-x), a MySQL database with the dynamic processing being handled by PHP. LEMP is an acronym for Linux, Engine-x (Nginx), MySQL and PHP. WordOps simplifies so much of the process of installing and configuring all the packages from the LEMP stack needed to deploy a site while taking care of creating virtual hosts in Nginx, installing WordPress, and even gets you a SSL certificate. It also installs some components that allow you to see statistics about the server’s workload. In this tutorial we’ll use WordOps to quickly and easily install WordPress on an Ubuntu 20.04 machine, and we’ll check out and explain some of the extra features that WordOps offers.

  • How to Find Out When a Webpage Was Published - Make Tech Easier

    When you’re doing research on a topic, it’s vital to ensure your sources are up to date. If you’re writing an academic paper, dates of publication are often required in the citations. The majority of the time, getting the date is easy: simply look on the site and find the published date to find how recent it was. Things get a little more complicated when there is no date listed on the webpage. When this happens, how do you know when a webpage was published?

  • How to install Wireshark 3.4.3 on a Chromebook

    Today we are looking at how to install Wireshark 3.4.3 on a Chromebook. Please follow the video/audio guide as a tutorial where we explain the process step by step and use the commands below.

  • Another Piece For The Home Network Puzzle – A Return To Cisco IOS! – Jon's FOSS Blog

    I’ve missed the good old days of configuring and setting up good quality switching hardware (like the big, huge Cisco switches and routers I used to experiment on with their IOS command line interface). I recently ordered this newer, smaller Cisco switch which can also provide power to a new “prosumer” WiFi AP (no power cables needed).

  • Making environment variables accessible in front-end containers - Red Hat Developer

    When building a container for a single-page application using any modern JavaScript framework (such as Angular, React, or Vue.js), you might find that the configuration settings are different depending on where the container will run. A typical case would be the base URL for your API, which will differ depending on whether you are testing the application or deploying it into production. Developers usually solve this problem using environment variables. Environment variables typically work on the backend because that is where code runs. But what if your application lives in the user’s browser? There are many ways around this limitation. In some cases, you might build a server whose endpoint holds the necessary parameters. Another workaround is to use PHP to inject the environment variables as globals in the JavaScript code. Both of these options work, but it would be ideal to inject the environment variables as part of the container build process. That way, you don’t have to change the codebase, and you can still deliver the application content using a static web server like NGINX. This article shows you how to inject environment variables directly into your codebase as you build your container.

  • The Strange Case of How We Escaped the Docker Default Container

    TL;DR During an internal container-based Red Team engagement, the Docker default container spontaneously and silently changed cgroups overnight, which allowed us to escalate privileges and gain...

  • How to copy and paste between host and VM