Advancedaidesktop.netmauicomputer-usescreen-awarenesssystem-control

Everywhere: Context-aware AI assistant for your desktop

Build and run Everywhere, the AI-powered desktop assistant that provides context-aware support with screen awareness, system command execution, and intelligent automation.

Step 1
What is Everywhere?
Everywhere is an advanced AI-powered desktop assistant that provides context-aware support directly on your computer. Built with .NET MAUI and Avalonia UI, it offers screen awareness, system command execution, intelligent automation with strategy engine, and MCP (Model Context Protocol) integration. Designed by @Sylinko and the community, Everywhere bridges the gap between AI models and actual desktop operations, enabling natural language control of your entire system.
```
Key Capabilities:
├── Screen awareness & screenshot analysis
├── System command execution
├── Intelligent automation via Strategy Engine
├── MCP server integration
├── Cross-platform support (Windows, macOS, Linux)
└── Natural language interface
```
Step 2
Technology stack
Everywhere is built on a sophisticated .NET-based architecture with multiple UI frameworks and AI integration layers:

Core Framework:
- .NET 10 (SDK 10.202+ required)
- C# 14 with nullable reference types
- Multi-platform App UI (.NET MAUI) 9.0.10+
- Avalonia UI 11.x for desktop controls
UI/UX:
- Avalonia DataGrid (.latest)
- HandDrawn theme with custom styling
- Dynamic screen coordinate system
- Floating window management
AI & Automation:
- ScreenPicker: Dynamic coordinate-based screen awareness
- StrategyEngine: Intelligent action planning and execution
- OCR and screenshot analysis
- MCP protocol implementation
- Terminal command executor
System Integration:
- Platform-specific system commands
- Dynamic screen bounds detection
- Hotkey management
- Process automation
Architecture:
- Clean architecture with MVVM patterns
- Dependency injection with Polly resilience
- Modular component design
- Local-first data with SQLite
```
Architecture:
├── Everywhere.App
│   ├── AppShell (main navigation)
│   ├── FloatingWindow (dynamic UI)
│   └── Screens (Home, System, Settings)
├── Everywhere.Core
│   ├── Logic layer
│   ├── Interfaces
│   └── DTOs
├── Everywhere.ScreenPicker
│   ├── Screen picker view
│   └── Dynamic coordinate system
├── Everywhere.StrategyEngine
│   ├── Strategy manager
│   ├── AI reasoning
│   └── Action execution
└── Everywhere.Terminal
    ├── Command executor
    └── Output parser
```
Step 3
Prerequisites
Before building Everywhere, ensure your system meets the requirements:

Platform Requirements:
- Windows: Windows 10 version 19041 or later
- macOS: macOS Monterey 12.0 or later (Xcode Command Line Tools required)
- Linux: X11-based desktop environment (Linux support in early development)
Build Tools:
- Git (latest release with LFS support)
- .NET SDK 10.202 or later
- JetBrains Rider 2026.1+ (recommended IDE, optional)
Important Notes:
- Linux support is experimental
- Ensure long path support on Windows
- Git LFS must be initialized for asset files
```
# Check .NET version (10.202+ required)
dotnet --version

# Check Git version
git --version

# Initialize Git LFS
git lfs install

# Windows: Enable long path support (run as Administrator)
git config --global core.longpaths true

# macOS: Install Xcode Command Line Tools
xcode-select --install
```

Step 4

Clone the repository

Everywhere uses Git submodules and LFS for dependencies and large assets. Clone with the --recursive flag to initialize everything properly.

# Clone with submodules
git clone --recursive https://github.com/Sylinko/Everywhere.git
cd Everywhere

# If already cloned without --recursive
git submodule update --init --recursive

# Verify submodules
git submodule status

Step 5
Development environment setup
After cloning, restore dependencies and set up the development environment:

Restore NuGet packages and workloads:
```
dotnet restore Everywhere.slnx
dotnet workload restore
```
Optional: Open in JetBrains Rider Rider 2026.1+ is recommended as it provides the best experience with .NET MAUI and Avalonia.
```
# Restore NuGet packages
dotnet restore Everywhere.slnx

# Restore MAUI workloads
dotnet workload restore

# Verify build
dotnet build --no-restore -c Release
```

Step 6

Build and run

Build and run Everywhere on your platform. The application uses .NET MAUI for cross-platform deployment.

# Quick run (uses default framework for your platform)
dotnet run --project src/Everywhere.App

# Or with explicit framework (Windows 64-bit)
dotnet run --project src/Everywhere.App -f net10.0-windows -c Debug

# Build for distribution
dotnet publish -c Release \
  -r win-x64 \
  --self-contained \
  -p:PublishSingleFile=true

Step 7

Core features

Screen Awareness (ScreenPicker): Dynamic coordinate-based screen detection, screenshot analysis, multi-monitor support.

Strategy Engine: Intelligent action planning, context-aware decision making, multi-step automation workflows.

Terminal Commands: Execute system commands safely with platform-specific handling.

MCP Integration: Model Context Protocol support with server mode operation.

Floating UI: Dynamic window positioning, always-on-top capability, custom theming.

// Example: Screen coordinate detection
public class ScreenPickerService
{
    public ScreenBounds GetCurrentScreenBounds() =>
        Screen.AllScreens[
            Screen.FromPoint(Mouse.GetPosition())
        ].WorkingArea;
}

// Example: Strategy execution
public class StrategyEngine
{
    public async Task ExecuteStrategy(StrategyContext context)
    {
        var plan = await _aiReasoner.CreatePlan(context.Goal);
        foreach (var action in plan.Actions)
        {
            await _actionExecutor.Execute(action);
        }
    }
}

Step 8

Configuration

Configure Everywhere using the built-in settings UI or by editing the configuration file located at:

Windows: %APPDATA%\Everywhere\settings.json
macOS: ~/Library/Application Support/Everywhere/settings.json
Linux: ~/.config/Everywhere/settings.json

{
  "AI_Model": {
    "provider": "openai",
    "apiKey": "your-api-key",
    "model": "gpt-4o"
  },
  "Hotkeys": {
    "trigger": "Ctrl+Alt+V",
    "screenshot": "Ctrl+Alt+Shift+V"
  },
  "ScreenPicker": {
    "refreshRate": 100,
    "maxWidth": 3840,
    "maxHeight": 2160,
    "multiMonitorSupport": true
  },
  "MCP_Server": {
    "enabled": false,
    "port": 8765
  }
}

Step 9
Troubleshooting
Rider shows errors in .axaml files: Update to Rider 2026.1+, clean and rebuild.

File locked/build errors: Delete obj/ and bin/ folders, clear NuGet cache.

ScreenPicker not detecting coordinates: Check screen capture permissions in OS settings.

MCP server mode fails to start: Check if port 8765 is in use.
```
# Clean build artifacts
rm -rf obj/ bin/
dotnet clean && dotnet restore && dotnet build --no-incremental

# Check for port conflicts
lsof -i :8765

# Clear NuGet cache
dotnet nuget locals all --clear
```
Step 10
Resources
Official Repository: https://github.com/Sylinko/Everywhere (5,974+ stars)

Documentation:
- Build Guide: https://github.com/Sylinko/Everywhere/blob/main/docs/build.md
- Patches: https://github.com/Sylinko/Everywhere/blob/main/docs/patches.md
Related Technologies:
- .NET MAUI: https://dotnet.microsoft.com/en-us/apps/maui
- Avalonia UI: https://avaloniaui.net/
- Model Context Protocol: https://modelcontextprotocol.io/
```
Everywhere: https://github.com/Sylinko/Everywhere
Stars: 5,974+

Docs:
├── build.md
├── patches.md
├── ScreenPicker/
├── StrategyEngine/
└── Terminal/

Related:
├── .NET MAUI
├── Avalonia UI
└── MCP
```

Everywhere: Context-aware AI assistant for your desktop

What is Everywhere?

Technology stack

Prerequisites

Clone the repository

Development environment setup

Build and run

Core features

Configuration

Troubleshooting

Resources

Feature requests

Discussion