libimobiledevice.org

FOSS stands for Free and Open-Source Software: software whose source code anyone can inspect, modify, and redistribute under the terms of its license. It is worth caring about if you want to verify what an app does with your data, keep using it without an account or subscription, or adapt it yourself. It is not the same as "freeware" (zero price, closed code), and "free" in FOSS refers to freedom, not cost — a FOSS app can still sell support, hosting, or perks.

The two words inside FOSS

FOSS bundles two overlapping traditions that are often treated as one:

• Free software — the emphasis is on the user's freedoms: run the program for any purpose, study how it works, modify it, and share copies or modified versions. The "free" is about liberty, which is why the common shorthand is "free as in speech, not free as in beer."
• Open-source software — the emphasis is on the development model: source code is publicly available and the license permits derived works. It is a more pragmatic framing aimed at businesses and collaboration.

In practice, a license that grants the four freedoms above is also open source, so the combined term FOSS (or FLOSS, adding "libre") is used when you want to cover both without picking a side in the philosophical debate.

Free, open source, and freeware are three different things

The practical test is not the price tag. A $0 download with hidden code is freeware, not FOSS. A FOSS project can charge for a hosted service or a "supporter" tier while the core app stays free — Audion, for example, describes itself as "free and open source" with a Supporter option where donations "unlock account sync perks," while the app itself lists "no subscriptions, no ads, no tracking."

What licenses actually require

The license is what turns "you can see the code" into "you are allowed to do something with it." Three families cover most cases:

• Permissive (MIT, Apache 2.0) — you can use, modify, and ship the code in closed products, usually as long as you keep the copyright notice. Apache 2.0 adds an explicit patent grant.
• Copyleft (GPL, AGPL) — if you distribute a modified version, you must release your changes under the same license. AGPL extends this to software offered over a network, which matters for self-hosted servers.
• Weak copyleft (LGPL, MPL) — copyleft applies to the modified files or library, not necessarily your whole application.

If your goal is simply to use a FOSS app, the license rarely restricts you. It matters when you fork it, bundle it into your own product, or run a modified version as a service.

Why people choose FOSS apps

The benefits are concrete rather than ideological:

• Verifiability — anyone can read the code or watch the build, so claims like "no telemetry" can be checked instead of trusted.
• No lock-in — your data and files stay in formats you control. Audion, for instance, scans local folders, reads tags, and keeps files local with "no accounts" and "no sign-in."
• Offline and privacy by default — a local-first player works without a connection and does not need to phone home.
• Longevity — if the original developer stops, the community can continue from the source.

How to check whether an app is really FOSS

1. Find the license. Look for a LICENSE file in the repository or a "License" link on the site. "Source available" or "we publish some code" is not the same as an OSI-approved license.
2. Find the source repository. A public repo with real commit history and issue activity is a good sign; a download-only page is not.
3. Check the build. Can you compile it from source, or at least see how releases are produced? Reproducible or documented builds make the "no tracking" claim auditable.
4. Read the pricing page carefully. Free core plus paid hosting or sync is normal and still FOSS. What you are checking is whether the code is free, not whether every service is.

Where FOSS falls short

• Support and pace — many projects are maintained by volunteers, so updates and bug fixes can be slow, and there may be no commercial support contract.
• Polish and edge cases — features you expect from paid software (advanced sync, mobile parity, integrations) may lag or be community-contributed.
• Fragmentation — forks and plugin ecosystems can split effort, so a plugin you rely on may go unmaintained.
• Hidden costs elsewhere — "free" often means you supply the hardware, hosting, or time. Running a self-hosted server, for example, needs a machine and some setup even when the software costs nothing.

A quick decision guide

• Choose FOSS when you want to verify behavior, avoid accounts and tracking, keep files local, or be able to fork and extend the tool.
• Choose proprietary or freeware when you need guaranteed support, a polished mobile experience out of the box, or features only a funded team maintains.
• When in doubt, check the license and the repository first — that single step separates genuine FOSS from marketing language.

Arx Libertatis is an improved, cross-platform, open-source engine for Arx Fatalis, the 2002 first-person RPG/dungeon crawler/immersive sim from Arkane Studios. To play on Linux, you install Arx Libertatis (official Linux builds are provided), then point it at a copy of the original Arx Fatalis game data — the engine itself does not include the game. You need to own or otherwise obtain Arx Fatalis or its demo before you can play.

What Arx Libertatis actually is

Arx Libertatis is a port and modernization of the Arx Fatalis engine, based on the publicly released Arx Fatalis source code and available under the GPL 3+ license. Version 1.2.1 supports modern systems, brings the game to new platforms, and removes bugs and limitations of the original release.

Two things follow from that:

• The engine is free and open source. You can download, inspect, and redistribute the code under the GPL.
• The game data is not included. The license covers the engine only. The art, audio, levels, and other assets remain part of the commercial game, so you must supply them yourself.

The game itself features crafting, melee and ranged combat, and a distinctive spellcasting system where you draw runes in real time to cast the spell you want.

What you need before installing

The original game is sold through storefronts such as GOG.com, the Microsoft Store, and the Bethesda Store, and it also has a demo. Any of these gives you the data files the engine needs.

Installing Arx Libertatis on Linux

Arx Libertatis provides official builds for Windows and Linux. Beyond those, it has been packaged for macOS (Homebrew), FreeBSD, DragonFly BSD, NetBSD, OpenBSD, Haiku, and Pandora, and will likely compile and work on other operating systems.

On Linux, you have two practical routes:

Option 1: Use a distribution package

Check whether your distribution ships Arx Libertatis in its repositories. If it does, install it through your normal package manager. This is the least manual path and keeps updates tied to your system.

Option 2: Use the official Linux build

Download the Linux build from the project's download page and unpack it. This works regardless of whether your distribution packages the engine, and it lets you run a specific version such as 1.2.1.

If neither fits, the source is available on GitHub, so you can build it yourself — the project notes it will likely compile on other systems too.

Pointing the engine at your game data

The engine needs to find the Arx Fatalis data files. The general flow is:

1. Install or unpack Arx Libertatis using one of the routes above.
2. Locate your Arx Fatalis data. If you bought the game from a storefront, the installer places the data files somewhere on disk; if you have the demo, it comes as its own set of files.
3. Tell Arx Libertatis where that data is when you first launch it, or place the data where the engine expects it.
4. Launch the game and confirm it reaches the main menu.

The expected result at each step is simple: the engine starts, finds the data, and loads the game rather than exiting with a "data not found" style error.

If the game does not run

Check these in order:

• Data path is wrong. The most common failure is the engine not finding the Arx Fatalis data. Re-check the path you gave it.
• You installed the engine but not the game. Arx Libertatis alone cannot run — it has no assets of its own.
• Graphics/driver problems. Since the engine targets modern systems, most rendering issues trace back to drivers or to running an old build. Try the current release (1.2.1).
• Wrong build for your system. Make sure you grabbed the Linux build, not the Windows one, if you installed manually.

Where to go next

The project plans to keep improving and modernizing the engine and to enable community customizations and mods. If you want to follow development or get help, the project links to its GitHub repository, Mod DB page, and community forums such as the TTLG Forum and the GOG.com forum. There are also community projects built around the game, including the Arx Insanity Mod and other Arx mods.

libimobiledevice is a cross-platform, free and open-source C library that speaks the native protocols iOS devices use, so a Linux machine can talk to an iPad directly without iTunes and without jailbreaking. It works if your iPad runs any iOS version from the first devices up to current firmware, and it gives you both bundled command-line tools and a higher-level API for tasks like reading device information, managing apps, backing up, browsing the filesystem, and restoring firmware.

Why Linux users need it

iTunes has never been available for Linux, which left Linux users unable to manage iPads and iPhones with Apple's own software. libimobiledevice was created to close that gap: it reimplements the native protocols needed to communicate with services running on iOS devices, so it does not depend on or bundle any Apple libraries. The project has been in development since 2007, which is why it covers the range from the earliest iOS hardware to the latest firmware.

What you can actually do with an iPad

The library exposes native device service APIs, and the bundled command-line utilities wrap them. Supported areas include:

• Device information — retrieve basic details about the connected iPad.
• Apps — manage installed applications.
• Backup — create and work with device backups.
• Filesystem — access files on the device.
• Debugging — interact with debugging services.
• Activation and provisioning — handle activation and provisioning workflows.
• SpringBoard and Syslog — interact with the home screen service and system logs.
• Firmware updates — up to restoring official firmware images.

How to use it

You have two paths, depending on whether you want quick commands or programmatic control.

Command-line tools

The project ships a set of command-line utilities that let you interact with iOS device services immediately, from pulling basic device information up to restoring official firmware images. This is the fastest route if you just want to do something once, or script it.

The library API

The architecture is designed with an object-oriented approach in mind, so the higher-level API makes it easier to interact with native device service APIs and to build bindings for other programming languages. This is the route to take if you are writing an application rather than running a one-off command.

Wireless access

If your iPad has "Wifi Sync" enabled, it can be accessed wirelessly and no longer requires a wired USB connection — this applies with iOS 11 and later. That means you can manage the device over the network instead of keeping it tethered.

Where it runs and how far it scales

Because it is written in C, the library is cross-platform: it has already been built and run on Linux, Mac, Windows, Android, and embedded ARM SoCs. It has also been integrated by popular community projects and by large implementations that interact with more than 10,000 devices, which is a useful reference point for scalability and efficiency.

Practical conditions to keep in mind

• No jailbreak required — the library talks the native protocols directly.
• No Apple libraries bundled — it is a reimplementation, not a wrapper around Apple code.
• Wireless only with Wifi Sync and iOS 11+ — older setups still need USB.
• Firmware restore is supported — the tooling reaches as far as restoring official firmware images.

If your goal is simply to get an iPad recognized and managed from a Linux desktop without installing iTunes, libimobiledevice is the intended tool for that job, and the bundled command-line utilities are the quickest way to start.

libimobiledevice is a cross-platform, free and open-source (FOSS) library written in C that communicates with iOS devices using Apple's native protocols, so you can manage an iPhone, iPad, iPod Touch, or Apple TV from Linux (and other platforms) without iTunes and without jailbreaking. It is the right tool if you want to read device information, install or remove apps, back up data, browse the filesystem, activate a device, or restore firmware from a non-Apple operating system. It is not a graphical consumer app — it ships as libraries plus a set of command-line utilities, so expect to work in a terminal.

What libimobiledevice actually is

The project reimplements the native protocols needed to talk to services running on iOS devices. Because it is a reimplementation, it does not depend on or bundle any libraries from Apple. That is the key design decision: it lets non-Apple systems speak the same language the device already understands.

The library has been in development since 2007, which is why it supports the range from the first iOS devices to the latest ones. It was originally born as "libiphone" because Linux users had capable but incompatible hardware like the iPhone 2G and no iTunes to manage it. The stated goal was to "allow penguins to talk to fruits."

What you can do with it

According to the project, the library and its bundled utilities let you interact with native device service APIs covering:

• Apps — install, upgrade, and uninstall applications
• Backup — create and manage device backups
• Filesystem — access files on the device
• Debugging — interact with debugging services
• Activation — activate a device
• Provisioning — manage provisioning profiles
• SpringBoard — interact with the home screen service
• Syslog — read device logs
• Firmware Updates — restore official firmware images

It also covers retrieving basic device information. The architecture uses an object-oriented approach, which makes it easier to build bindings for other programming languages and expose an OOP-based API.

Cross-platform and wireless support

The C implementation is what makes the library portable. It has already been built and run on:

For connectivity, devices with "Wi-Fi Sync" enabled can be accessed wirelessly and no longer require a wired USB connection on iOS 11 and later. That means you are not tied to a cable for every operation.

The bundled command-line tools

You do not have to write code to use the project. A set of command-line utilities ships with the library and covers everything from retrieving basic device information up to restoring official firmware images. The current release set includes:

• ifuse 1.2.0
• usbmuxd 1.1.1
• libplist 2.7.0
• libtatsu 1.0.5
• libusbmuxd 2.1.1
• libirecovery 1.3.1
• idevicerestore 1.0.0
• libimobiledevice 1.4.0
• ideviceinstaller 1.2.0
• libideviceactivation 1.1.1
• libimobiledevice-glue 1.3.2

In practice this means tasks like installing an app (ideviceinstaller) or restoring firmware (idevicerestore) are single commands rather than something you script from scratch.

How to get started

1. Download the components from the project site. The download section lists the individual libraries and utilities above, so you can pick what you need.
2. Install the dependencies and utilities for your platform. On Linux, distributions typically package these tools, and usbmuxd handles the USB multiplexing that lets the host talk to the device.
3. Connect the device over USB, or use Wi-Fi Sync if the device has it enabled and runs iOS 11 or later.
4. Verify the connection by retrieving basic device information with the bundled utilities before attempting anything more involved.
5. Run the specific utility for your task — for example, an app-management tool for installing software or a restore tool for firmware.

The exact package names and install commands vary by distribution and are not specified on the project page, so check your platform's package manager for the individual component names.

Who this is for

libimobiledevice is a good fit if you are a Linux user who needs to manage an iOS device without iTunes, or a developer who wants to build iPhone communication into an application. The project notes it has been integrated by popular community projects and by large implementations that interact with more than 10,000 devices, which is a useful reference point for scalability and efficiency.

It is a poor fit if you want a point-and-click consumer interface — the project is a library and a CLI toolset, not a GUI. If you need a graphical front end, you would look for one built on top of these libraries rather than the core project itself.

iOS is Apple's mobile operating system, the software that runs on iPhone and iPad. In app development, it defines both the platform you build for and the toolchain you use: native iOS apps are typically written in Swift, while cross-platform frameworks like Flutter compile to iOS as one of their targets. Choose native iOS when you need maximum performance and deep access to Apple features; choose a cross-platform approach when you want one codebase to cover iOS and Android together.

iOS as a platform

iOS is the operating system layer between the hardware and the apps users interact with. It ships on Apple's mobile devices and comes with a set of conventions — navigation patterns, permissions, notifications, and design expectations — that apps are expected to follow.

For a development team, that means two things:

• A defined target environment. You build against Apple's SDKs and device capabilities rather than a generic mobile spec.
• A review gate. Distribution through the App Store means your app is checked against Apple's guidelines before users can install it.

iOS vs. Android: user and developer view

From a user's perspective the difference is mostly ecosystem and interface conventions. From a developer's perspective the practical difference is fragmentation: iOS runs on a narrower, more predictable set of devices, while Android must account for many screen sizes, chipsets, and OS versions.

Native iOS development with Swift

Native iOS development means writing directly against Apple's platform using Swift. Locomotive Mobile describes its native offering as "Native solutions for iOS (Swift) and Android (Kotlin) with maximum performance," listing Swift for iOS alongside maximum performance and advanced features as the payoff.

Native is usually the right call when:

• The app depends on performance-critical work or heavy graphics.
• You need advanced or newly released Apple features as soon as they're available.
• The product is iOS-first and Android is not an immediate priority.

The trade-off is scope: a native iOS build does not give you an Android app. If you need both, you either build twice or use a cross-platform framework.

Where Flutter fits

Flutter is a cross-platform framework that produces apps for both iOS and Android from a single codebase. Locomotive Mobile positions it as "cross-platform apps with native performance and a single codebase," with the listed benefits being optimized performance, simplified maintenance, and reduced time to market.

That framing sets up the real decision:

• Flutter — one codebase, faster to ship to both platforms, simpler ongoing maintenance.
• Native iOS (Swift) — maximum performance and the deepest platform integration, at the cost of a separate Android effort.

Neither is universally correct. The choice follows from how performance-sensitive the app is, how much it leans on platform-specific features, and whether Android is in scope.

From idea to a published iOS app

The path is broadly the same whether you go native or cross-platform:

1. Define the product. Decide what the app does, who it's for, and which platforms it must reach.
2. Choose the stack. Native Swift, Flutter, or a mix — driven by the performance and reach requirements above.
3. Design the experience. Locomotive Mobile's UI/UX service covers responsive design, prototyping, usability testing, and a design system.
4. Build and test. Implement the app and validate it on real devices.
5. Distribute. Publish through the App Store, which requires passing Apple's review.
6. Maintain. Ship updates as the OS, devices, and user expectations change.

Steps 1 and 2 are where most of the downstream cost is decided. Picking native when cross-platform would have sufficed, or the reverse, is expensive to undo later.

Fitting iOS into a broader mobile strategy

Most products that start on iOS eventually face the Android question. Three common shapes:

• iOS only — justified when your audience is concentrated on Apple devices or you're validating the concept first.
• iOS first, Android later — ship native iOS, then decide whether Android is a second native build or a cross-platform rewrite.
• Both at once with Flutter — one codebase covering iOS and Android from launch, trading some platform depth for reach and speed.

Locomotive Mobile's portfolio shows the range this can cover: Mission Bible, a study app built with Flutter, Firebase, and Python, reports 100K+ downloads, a 4.8 rating, and 12K+ users — an example of a cross-platform build aimed at broad reach rather than a single-platform native app.

The practical rule: let your audience and your feature requirements pick the platform strategy, not the other way around. If you need iOS specifically for its performance ceiling or Apple-only capabilities, go native with Swift. If you need iOS and Android together without doubling the build, Flutter is the more direct route.