Tinfoil represents a powerful tool for media processing, enabling seamless integration with modern streaming and recording systems. Whether deploying on Windows, macOS, or Linux, its installation demands precision to ensure compatibility with hardware and software dependencies. This guide provides a structured approach to installation, troubleshooting, and optimization, ensuring users can harness tinfoil’s full potential while maintaining system stability and security.
The process begins with a thorough assessment of system requirements, including CPU architecture, RAM allocation, and OS version compatibility. Each platform—Windows, macOS, and Linux—presents unique challenges, from dependency management to permission errors, requiring tailored solutions. Beyond installation, users must address hardware-specific configurations, such as GPU acceleration, and mitigate security risks through verified downloads and isolated environments. By following these steps, users can achieve a reliable, high-performance setup tailored to their specific use case.
Installation Basics and System Requirements for Tinfoil
Tinfoil, a third-party add-on for Kodi, requires specific hardware and software configurations to ensure compatibility and optimal performance. Proper system verification minimizes installation errors and ensures seamless integration with existing media playback environments. Below are the prerequisites, compatibility checks, and dependency requirements for Windows, macOS, and Linux systems.
Hardware and Software Prerequisites
Tinfoil operates as a Kodi add-on, meaning its performance depends on the underlying system’s capabilities. The following specifications provide a baseline for smooth functionality:
Hardware Requirements:
CPU Architecture: x86_64 (64-bit) or ARM64 (for Raspberry Pi or Apple Silicon macOS). Tinfoil does not support 32-bit (x86) architectures due to dependency limitations.
RAM: Minimum 2GB (recommended 4GB or higher for multi-streaming or high-definition content).
Storage: At least 500MB free space for the add-on and temporary files. Additional storage may be required for cached streams or local media libraries.
Software Requirements:
Operating System Compatibility:
Windows: Version 10 (64-bit) or later. Windows 7/8 (32-bit) are unsupported due to missing dependencies.
macOS: Version 10.13 (High Sierra) or later, with Apple Silicon (ARM64) or Intel (x86_64) support. Rosetta 2 is required for Intel Macs running ARM-native Kodi versions.
Linux: Distributions with package managers (e.g., Debian/Ubuntu, Arch, Fedora) supporting Python 3.7+ and FFmpeg. Raspberry Pi OS (64-bit) is explicitly supported for ARM devices.
Key Dependencies:
Tinfoil relies on external libraries and tools for decoding, streaming, and system integration. The following must be pre-installed or resolved during setup:
Tinfoil’s core functionality depends on Python 3.7–3.10, FFmpeg 4.4+, and libusb 1.0+ for hardware passthrough (e.g., USB tuners). Missing dependencies result in playback errors or failed installations.
System Compatibility Verification
Before installing Tinfoil, verify system compatibility to avoid conflicts or unsupported configurations. Follow these steps to assess readiness:
Step 1: Check OS and Architecture
Windows: Open Settings > System > About and confirm "System type" is 64-bit. Use `wmic os get osarchitecture` in Command Prompt for automation.
macOS: Run `uname -m` in Terminal. Outputs `x86_64` (Intel) or `arm64` (Apple Silicon).
Linux: Execute `uname -m` (outputs `aarch64` for ARM, `x86_64` for Intel/AMD). For Debian/Ubuntu, also check `lsb_release -a` for distribution version.
Step 2: Validate Python and FFmpeg
Python: Run `python3 --version` or `python --version` (Windows). Ensure output is 3.7–3.10. Install via python.org if missing.
FFmpeg: Execute `ffmpeg -version` in Terminal/Command Prompt. Confirm version 4.4 or higher. Install via:
macOS/Linux: Package managers (e.g., `sudo apt install ffmpeg` on Debian/Ubuntu).
Step 3: Detect Conflicting Software
Kodi Plugins: Disable or uninstall competing add-ons (e.g., Seren, The Crew, or other third-party repositories) that may duplicate Tinfoil’s functionality.
Media Players: Ensure no other players (e.g., VLC, MPV) are configured to handle `.m3u8` or `.ts` streams, which Tinfoil manages directly.
Firewall/AV Software: Temporarily disable real-time protection (e.g., Windows Defender, ClamAV) during installation to prevent dependency blocking.
Dependency Requirements and Version Specifications
Tinfoil’s dependencies must meet strict version criteria to avoid runtime errors. Below is a detailed list with installation commands for each platform:
Extract to `Kodi/addons/plugin.video.tinfoil/` (create folders if missing).
Restart Kodi and enable the add-on in Add-ons > My add-ons > Video add-ons.
Requires manual dependency resolution if errors occur.
Package Manager (Optional)
Use a repository like Nerds on Sticks for pre-configured Kodi builds.
Install via Kodi’s Add-ons > Install from zip (if the repo provides a `.zip`).
Limited to specific Kodi versions; may lack updates.
macOS
Homebrew (Recommended)
Clone the Tinfoil repo: `git clone https://github.com/FallenBagel/tinfoil.git`.
Navigate to the folder and run `python3 setup.py install`.
Copy the add-on files to `~/Library/Application Support/Kodi/addons/plugin.video.tinfoil/`.
Requires Python and FFmpeg installed via Homebrew.
Direct Download
Download the `.zip` and extract to `~/Library/Application Support/Kodi/addons/`.
Enable in Kodi’s add-on manager.
Manual dependency checks are
Step-by-Step Installation Guides for Different Operating Systems
The installation process for Tinfoil varies across operating systems, requiring distinct approaches depending on the platform's package management system, native installers, or manual compilation. Below are detailed, platform-specific instructions covering Windows, macOS, and Linux, including silent installation methods, dependency resolution, and post-installation configurations. Each method ensures compatibility while minimizing system-wide conflicts, particularly when using virtual environments.
Windows Installation via Official Installer
Windows users can install Tinfoil using the official `.exe` or `.msi` installer, which supports both interactive and silent (unattended) installation modes. Silent installation is recommended for automated deployments or enterprise environments to avoid manual intervention.
Prerequisites:
Administrative privileges (required for system-wide installation).
Python 3.7+ (recommended for compatibility with Tinfoil’s dependencies).
Visual C++ Redistributable (if compiling from source or using certain dependencies).
`/L*v install.log` – Logs installation details to `install.log` (for debugging).
`ALLUSERS=1` – Installs for all users (requires admin rights).
Post-Installation Configuration:
Verify the installation by running `tinfoil --version` in Command Prompt.
If the command fails, manually add the installation directory (e.g., `C:\Program Files\Tinfoil`) to the `PATH` via System Properties > Environment Variables.
macOS Installation Methods
macOS supports multiple installation methods, including Homebrew (recommended), manual compilation from source, and troubleshooting common permission errors. Homebrew simplifies dependency management, while manual compilation offers customization but requires additional steps.
Prerequisites:
Xcode Command Line Tools (for compiling from source):
- Error: `xcodebuild` or `clang` not found.
Solution: Install Xcode Command Line Tools:
xcode-select --install
- Error: Python package conflicts.
Solution: Use a virtual environment (see Virtual Environment Installation below).
Linux Installation Methods
Linux distributions offer diverse package formats (`.deb`, `.rpm`, `.tar.gz`, etc.), each requiring specific commands. Below is a categorized list of installation methods for major distributions, including Debian/Ubuntu, Arch Linux, Fedora, and containerized options like Snap and Flatpak.
Prerequisites:
Root or `sudo` privileges (for system-wide installation).
flatpak install flathub com.github.TeamTinfoil.Tinfoil
flatpak run com.github.TeamTinfoil.Tinfoil
Post-Installation Configuration Summary
After installing Tinfoil, configure the environment to ensure proper functionality. Below is a responsive table summarizing OS-specific steps for adding to `PATH`, creating shortcuts, and verifying installation.
Configuration Step
Windows
macOS
Linux (Debian/Ubuntu)
Linux (Arch/Fedora)
Add to PATH
Open System Properties > Environment Variables.
Under System Variables, edit Path.
Add: C:\Program Files\Tinfoil (adjust path).
Restart terminal or Command Prompt.
Add to shell configuration (e.g., ~/.zshrc or ~/.bashrc):
export PATH="$PATH:$HOME/.
Troubleshooting Common Installation Errors
Installation issues with Tinfoil often stem from missing dependencies, hardware compatibility conflicts, or permission restrictions. This section provides structured solutions for resolving frequent errors, including `libusb` detection failures, Python module deficiencies, GPU driver interference, and dependency conflicts across package managers. Diagnostic techniques, such as verbose logging, are also detailed to isolate root causes efficiently.
Resolving `libusb` Detection Failures
The `libusb` library is critical for Tinfoil’s hardware communication, particularly on Linux and macOS. Errors like "Failed to initialize libusb" or "No devices found" typically indicate missing or improperly configured dependencies. Below are systematic fixes:
Common Causes and Solutions
Tinfoil requires `libusb-1.0` (version ≥1.0.20) and its development headers. Incorrect permissions or conflicting installations may prevent detection.
Verify Installation on Linux (Debian/Ubuntu):
Ensure `libusb-1.0-0` and `libusb-1.0-0-dev` are installed via:
Reboot the system after installation to apply changes.
macOS (Homebrew):
Install or reinstall `libusb` using:
brew install libusb && brew link --overwrite libusb
If the link fails, manually add to `/etc/paths`:
echo "/usr/local/opt/libusb/lib" | sudo tee -a /etc/paths
Windows (Manual Installation):
Download the latest `libusb` binaries from libusb.info and ensure the `libusb-1.0.dll` is in the same directory as Tinfoil’s executable. Add the directory to `PATH` via System Environment Variables.
Permission Issues:
On Linux, add the user to the `libusb` group:
sudo usermod -aG libusb $USER
Log out and back in for changes to take effect.
Kernel Module Conflicts (Linux):
Check if `usbhid` or `uinput` modules are blocking access:
lsmod | grep usb
Temporarily blacklist conflicting modules in `/etc/modprobe.d/blacklist.conf`:
blacklist usbhid
Reboot afterward.
Verification
Test `libusb` functionality with:
lsusb # Lists connected USB devices
sudo dmesg | grep usb # Checks kernel logs for USB activity
Diagnosing and Fixing GPU Driver Interference
Tinfoil relies on hardware acceleration via AMD/Intel GPUs. Conflicts with proprietary drivers (e.g., AMDGPU-PRO, Intel OpenCL) or misconfigured environments can lead to crashes or performance degradation. Below is a structured approach to identify and resolve these issues:
Symptoms of GPU Driver Conflicts
Tinfoil fails to launch with errors like "OpenCL initialization failed" or "GPU not detected."
High CPU usage with no GPU utilization in task managers.
Artifacts or rendering errors during emulation.
Diagnostic Steps
Check OpenCL/Vulkan Support:
Use `clinfo` (for OpenCL) or `vulkaninfo` (for Vulkan) to verify GPU compatibility:
Resolving Dependency Conflicts in Package Managers
Conflicts arise when multiple package managers (e.g., `apt`, `brew`, `dnf`) install conflicting versions of dependencies like Python, `libusb`, or `ffmpeg`. Below are strategies to mitigate these issues:
Common Scenarios and Fixes
Python Version Conflicts:
Tinfoil requires Python 3.7–3.10. Conflicts occur if the system Python or a package manager (e.g., `pip`) installs an incompatible version.
Isolate Python Environments:
Use `venv` or `conda` to create a dedicated environment:
LibUSB Conflicts Between `apt` and `brew` (macOS):
Homebrew may install `libusb` in `/usr/local`, while macOS’s system libraries reside in `/usr`. Use `brew link` to resolve:
brew link --overwrite libusb
If conflicts persist, manually specify paths in Tinfoil’s configuration or build from source with custom flags.
FFmpeg/Codecs Conflicts:
Package managers may install outdated or stripped-down versions of `ffmpeg`. Use static builds or compile from source:
Advanced Configuration and Optimization Post-Installation
Tinfoil’s default settings provide functional performance, but hardware-specific optimizations and fine-tuned configurations can significantly enhance transcoding efficiency, compatibility, and integration with media ecosystems. This section covers hardware-specific adjustments, optional settings for performance tuning, integration with media servers, and automation of maintenance tasks. Optimizations are categorized by use case—such as live TV processing or DVR recordings—to ensure balanced trade-offs between quality and resource utilization.
Hardware-Specific Configuration for Performance Optimization
Tinfoil leverages hardware acceleration features available in modern CPUs and GPUs, but configuration varies by architecture. Below are optimized settings for common hardware setups, including AMD APUs and NVIDIA GPUs, with considerations for transcoding workloads.
AMD APUs (e.g., Ryzen 5/7 with Radeon Graphics)
AMD APUs integrate CPU and GPU cores, enabling unified video processing (UVP) for H.264/H.265 transcoding. To maximize performance:
Enable UVP in Tinfoil:
Ensure the `ffmpeg` binary used by Tinfoil includes AMD AMF (Advanced Media Framework) support. Verify via:
ffmpeg -hide_banner -hwaccels
Expected output should list `amf` among available hardware accelerators.
Configure `tinfoil.conf`:
Add or modify the following entries in the configuration file:
- Profile Selection:
For H.264, use `h264_nvenc`; for H.265 (HEVC), use `hevc_nvenc`. Example:
transcoding_profile = h264_nvenc
- Bitrate and Quality Trade-offs:
NVENC excels at low-latency transcoding but may require manual bitrate adjustments. Example for live TV:
target_bitrate = 8000 # kbps (adjust based on source quality)
max_bitrate = 10000 # Prevents buffer overflows
Checklist of Optional Settings for Performance Tuning
Tinfoil’s behavior can be customized via configuration files (`tinfoil.conf` or GUI preferences) to align with specific workflows. Below is a categorized checklist of adjustable parameters, grouped by function.
Transcoding Profiles
Bitrate Limits:
Set `target_bitrate` (kbps) to balance quality and file size. Example for 1080p:
target_bitrate = 6000 # CRF mode (alternative: use `crf = 23` for VBR)
- Use `min_bitrate` and `max_bitrate` to constrain variability in variable bitrate (VBR) encoding.
Resolution Scaling:
Enable downscaling for high-bitrate sources:
max_width = 1920
max_height = 1080
- Disable scaling for lossless passthrough:
passthrough_resolutions = 3840,2160 # 4K/UHD
Hardware Acceleration
Fallback Mechanisms:
Define fallback encoders if hardware acceleration fails:
fallback_encoder = libx264
- GPU Memory Allocation:
For NVIDIA GPUs, limit memory usage to avoid crashes:
nvenc_gpu_mem_limit = 50 # Percentage of total GPU RAM
Network and Storage
Buffering:
Adjust `input_buffer_size` (ms) to reduce stuttering in live streams:
input_buffer_size = 5000 # 5-second buffer
- Disk I/O Priorities:
On Linux, set `ionice` priorities for background transcoding:
ionice_class = 3 # Idle I/O scheduling
Integration with Media Servers for Automated Processing
Tinfoil can be configured to act as a transcoding backend for media servers like Plex or Jellyfin, enabling on-the-fly processing of recordings. Below are integration steps and required configurations.
Plex Media Server Integration
1. Enable Tinfoil as a Transcoder:
In Plex, navigate to Settings > Server > Transcoding and add Tinfoil’s FFmpeg binary path (e.g., `/opt/tinfoil/ffmpeg`).
Configure Plex to use Tinfoil for specific codecs:
/opt/tinfoil/ffmpegAMF1073741824
2. Shared Library Paths:
Ensure Tinfoil’s `libraries` folder is accessible by Plex. Symlink if necessary:
Restrict transcoding to specific users via Jellyfin’s Dashboard > Users > [User] > Transcoding.
Comparison of Default vs. Optimized Tinfoil Settings
The table below contrasts default settings with optimized configurations for two common use cases: live TV streaming and DVR recordings. Adjustments prioritize either latency (live TV) or quality (DVR).
Setting
Default (Live TV)
Optimized (Live TV)
Default (DVR)
Optimized (DVR)
hardware_acceleration
auto
nvenc (NVIDIA) or amf (AMD)
auto
nvenc (preset: p4) or amf
target_bitrate (kbps)
4000
6000 (with max_bitrate=8000)
5000
7000 (CRF 20 for VBR)
input_buffer_size (ms)
2000
5000 (reduces stutter)
3000
2000 (lower latency for playback)
max_concurrent_transcodes
4
2 (
Security and Privacy Considerations During Tinfoil Installation
Ensuring the integrity and security of Tinfoil during installation is critical to prevent unauthorized access, data leaks, or malware infiltration. This section covers verification methods for download authenticity, network hardening techniques, secure credential management, and isolation strategies to mitigate risks. Proper implementation of these measures aligns with defense-in-depth principles, reducing attack surfaces while maintaining functionality.
Verification of Download Integrity and Authenticity
Tinfoil’s official releases must be verified using cryptographic checksums and GPG signatures to confirm their origin and prevent tampering. Malicious actors may distribute compromised binaries or modified packages, particularly on third-party repositories or untrusted sources.
- Use tools like `sha256sum` (Linux/macOS) or `CertUtil` (Windows) for verification.
GPG Signature Verification
Import the project’s public GPG key from the repository (e.g., `tinfoil.asc`).
Verify the signature using:
gpg --verify tinfoil-.tar.gz.sig tinfoil-.tar.gz
- Ensure the output confirms the signature is valid and matches the expected key fingerprint.
Additional Safeguards
Avoid downloading Tinfoil from unofficial sources (e.g., random forums or third-party sites).
Use HTTPS for all downloads to prevent man-in-the-middle attacks.
For Linux packages (e.g., `.deb`, `.rpm`), verify repository signatures via `apt-key` or `rpm --checksig`.
Network Security Configuration to Mitigate Attacks
Tinfoil’s network exposure—particularly when integrated with DVRs or APIs—requires strict controls to block unauthorized access. Misconfigured firewalls or open ports can enable exploits like remote code execution or data exfiltration.
Firewall Rules for Tinfoil
Restrict inbound connections to only necessary ports (e.g., default HTTP/HTTPS ports if Tinfoil exposes a web interface).
Example `iptables` rules (Linux):
iptables -A INPUT -p tcp --dport 80 -j ACCEPT # Allow HTTP (adjust as needed)
iptables -A INPUT -p tcp --dport 443 -j ACCEPT # Allow HTTPS
iptables -A INPUT -s -j ACCEPT # Whitelist internal IPs
iptables -P INPUT DROP # Default deny all other traffic
- On Windows, use Windows Defender Firewall with Advanced Security to block all inbound traffic except explicitly allowed services.
Port Forwarding and NAT Considerations
Avoid exposing Tinfoil directly to the internet unless absolutely necessary.
If remote access is required, use a VPN or SSH tunnel instead of port forwarding.
For DVR integrations, restrict API endpoints to internal networks or use API gateways with authentication.
Network Traffic Monitoring
Log all Tinfoil-related traffic via system logs (`/var/log/syslog`, `journalctl`, or Windows Event Viewer).
Monitor for unusual patterns:
Unexpected outbound connections to untrusted domains.
High-frequency API calls from unknown IPs.
Use tools like `tcpdump` or Wireshark to inspect traffic:
tcpdump -i eth0 -w tinfoil_traffic.pcap 'host '
Secure Management of API Keys and Credentials
Hardcoding API keys or credentials in configuration files poses significant risks, as exposed files can lead to account compromise or unauthorized access. Best practices include environment variables, secret managers, and least-privilege access.
Avoid Hardcoding Credentials
Never store API keys (e.g., for DVR integrations) in plaintext in `config.yml` or similar files.
Example of insecure practice:
dvr:
api_key: "sk_live_123abc..." # Vulnerable to exposure
Recommended Storage Methods
Environment Variables: Use system-level variables (e.g., `export TINFOIL_DVR_API_KEY="..."`).
Secret Management Tools:
Linux: `/etc/environment` or tools like `pass`/`gpg`-encrypted files.
Windows: Windows Credential Manager or Azure Key Vault.
Docker: `--env-file` or Kubernetes Secrets.
Configuration File Exclusion:
Add sensitive files to `.gitignore` and restrict permissions:
chmod 600 ~/.tinfoil/secrets.env
Least-Privilege Access
Use short-lived tokens or role-based access control (RBAC) for DVR/API integrations.
Rotate keys periodically (e.g., every 90 days) and revoke compromised keys immediately.
Isolation Techniques for Tinfoil Deployment
Deploying Tinfoil in a sandboxed environment limits the impact of potential breaches by containing processes, network access, and system modifications. Containerization and virtualization are key strategies.
Docker Containerization
Run Tinfoil in a dedicated Docker container with minimal host access:
FROM ubuntu:22.04
USER nobody
WORKDIR /app
COPY tinfoil /usr/local/bin/
CMD ["tinfoil", "--config", "/etc/tinfoil/config.yml"]
- Restrict container capabilities:
docker run --cap-drop=ALL --cap-add=NET_BIND_SERVICE --read-only ...
- Use Docker’s user namespace remapping to further isolate processes.
User-Mode Linux (UML) or Virtual Machines
Deploy Tinfoil in a lightweight VM (e.g., QEMU/KVM) with:
Disabled USB/pass-through devices.
Network interfaces configured for NAT or host-only mode.
Example `libvirt` XML snippet for network isolation:
SELinux/AppArmor for Mandatory Access Control
Enforce strict policies to limit Tinfoil’s filesystem/network access:
SELinux (Linux):
semanage permissive -a tinfoil_t # Custom policy for Tinfoil
- AppArmor (Ubuntu/Debian):
sudo aa-enforce /etc/apparmor.d/tinfoil
Audit Logs and Traffic Analysis for Suspicious Activity
Continuous monitoring of Tinfoil’s logs and network traffic helps detect anomalies such as brute-force attacks, data leaks, or unauthorized API usage. Logs should be centralized and analyzed for deviations from normal behavior.
Key Log Sources
Tinfoil Application Logs:
Check for repeated failed API calls or unusual DVR commands.
Example log entry indicating brute-force attempt:
[2024-02-15 14:30:45] ERROR: Invalid API key from IP 192.0.2.42 (attempt 5/10)
- System Logs:
Monitor for unexpected child processes spawned by Tinfoil:
Deploy to capture Tinfoil-related connections and generate alerts for:
Unusual payload sizes (e.g., large data uploads).
Connections to known malicious IPs (via threat intelligence feeds).
Suricata:
Use custom rules to detect Tinfoil-specific anomalies:
alert tcp any any -> any 80 (msg:"Tinfoil HTTP Unusual User-Agent"; flow:to_server; content:"User-Agent"; pcre:"/^Tinfoil\/[^ ]* (unknown|test)/i";)
Log Retention and Analysis
Retain logs for at least 90 days, with critical events (e.g., failed logins) stored indefinitely.
Use tools like ELK Stack (Elasticsearch, Logstash, Kibana) to correlate logs across systems.
Set
Installing tinfoil successfully hinges on meticulous preparation, from verifying system compatibility to resolving dependency conflicts and optimizing performance. This guide has outlined each critical phase—from basic installation to advanced configurations—while emphasizing security best practices to safeguard against vulnerabilities. Whether integrating tinfoil with media servers or fine-tuning settings for live TV processing, the key lies in methodical execution and continuous monitoring. By adhering to these principles, users can deploy tinfoil with confidence, ensuring seamless functionality across diverse hardware and software landscapes.
FAQ
What is the Tinfoil installer and how does it work?
Tinfoil is a third-party app store for Android that allows users to install APK files directly, bypassing Google Play Store restrictions. It’s often used to sideload apps, access region-locked content, or install apps not available in certain countries. The installer itself is a tool to manage these APK installations and updates.
What does "install ticket only" mean when using Tinfoil?
"Install ticket only" in Tinfoil means the app will only download and install the necessary files (tickets) to play a game or use an app, without installing the full game data. This is useful for saving storage space or troubleshooting, but the full game/data must still be installed separately via another method.
How does Tinfoil work technically?
Tinfoil works by intercepting and modifying game updates from services like Nintendo Switch Online, allowing users to install or downgrade games without physical cartridges. It exploits vulnerabilities in Nintendo’s update system to extract and repack game files, enabling offline play or custom modifications. It requires a rooted or patched Switch and is primarily used for piracy or homebrew purposes.
Can you put tin foil in an air fryer?
No, you should never put aluminum foil in an air fryer. The foil can block airflow, cause uneven cooking, or even spark and start a fire due to the high heat and electrical components. Use foil-safe alternatives like silicone liners or parchment paper instead.
Can you put tin foil in the oven?
Yes, you can use small amounts of heavy-duty aluminum foil in the oven, as long as it’s not touching the heating element or blocking vents. Avoid placing foil directly on the oven rack or using it to line the bottom if it could melt or ignite. Check your oven manual for specific guidelines.
Can you put tin foil in the microwave?
No, you should never put aluminum foil in the microwave unless it’s specifically designed for microwave use (like a microwave-safe foil tray). Loose foil can cause sparks, fires, or damage to the microwave by reflecting microwaves unevenly. Use microwave-safe containers instead.
Leave a Comment
Comments are moderated before appearing. The data you submit is processed according to the Privacy Policy of www.linuxunplugged.com.