awesome-repositories.com
Blog
MCP
awesome-repositories.com

Découvrez les meilleurs dépôts open-source grâce à notre recherche par IA.

ExplorerRecherches sélectionnéesAlternatives open sourceLogiciels auto-hébergésBlogPlan du site
ProjetServeur MCPÀ proposNotre méthodologiePresse
Mentions légalesConfidentialitéConditions d'utilisation
© 2026 Bringes Technology SRL·VAT RO45896025·hello@awesome-repositories.com
·
mozilla-firefox avatar

mozilla-firefox/firefox

0
View on GitHub↗
11,305 stars·888 forks·JavaScript·other·13 vueswww.firefox.com↗

Firefox

Firefox is a cross-platform web browser engine designed to render web content, execute JavaScript, and manage secure browsing sessions. It utilizes a multi-process isolation architecture that distributes browser tasks across independent operating system processes to ensure stability and prevent site-specific failures from impacting the entire application. The engine incorporates a sandboxed execution environment to restrict web content and untrusted scripts to isolated memory compartments, enforcing security policies that prevent unauthorized access to system resources.

The project distinguishes itself through a high-performance rendering pipeline that decouples visual updates from the main thread, enabling fluid scrolling and animation performance. It features a formal cross-language binding layer that connects high-level scripting environments with low-level system logic, facilitating memory-safe performance improvements through the integration of Rust components. Additionally, the browser employs a declarative component framework that uses reactive properties and shadow DOM encapsulation to ensure consistent rendering and modular feature development across the user interface.

The browser provides a comprehensive suite of capabilities for web standards implementation, privacy protection, and automated testing. It includes infrastructure for local machine learning, persistent data management, and cross-device synchronization of user profiles and settings. The platform also offers extensive developer tools for inspecting network activity, profiling performance, and debugging scripts, alongside a robust framework for third-party extension development.

The codebase is structured to support complex browser operations, including automated testing, build configuration, and system-level integration. It is distributed as a complete application package for major operating systems, with documentation and build tools provided to support cross-platform development and continuous integration workflows.

Features

  • Script Execution Contexts - Runs JavaScript code within specific process contexts to handle events and manage state across the browser architecture.
  • Privacy Protection - Blocks tracking scripts and fingerprinting attempts to prevent third parties from monitoring browsing habits across different websites.
  • Web Applications - Runs complex web-based software within a sandboxed environment using standardized APIs.
  • Process Isolation Architectures - Distributes browser tasks across independent operating system processes to ensure stability and prevent site-specific failures from crashing the entire application.

Recherche par IA

Explorez plus de dépôts awesome

Décrivez vos besoins en langage naturel — l'IA classe des milliers de projets open source sélectionnés par pertinence.

Start searching with AI
  • Browser Engines - Implements a cross-platform engine that renders web content and executes JavaScript within an isolated process architecture.
  • Web Rendering Engines - Converts web content into visual frames by processing display lists, managing coordinate transforms, and executing GPU-accelerated rendering commands.
  • Isolated Tab Rendering - Renders web pages and handles network requests within isolated tab environments that maintain distinct browsing states and elevated security privileges.
  • Privacy-Focused Web Browsers - Functions as a privacy-focused web client that enforces security policies and blocks trackers to protect user data.
  • Web Browsers - Develops a high-performance web browser engine that renders content and manages system resources.
  • Process Isolation - Executes specific tasks in restricted utility processes to apply custom security policies and isolate operations from the main browser environment.
  • Web Security - Implements advanced tracking protection, sandboxing, and cryptographic standards to safeguard user data and browsing contexts.
  • Origin-Based Permission Managers - Controls access to sensitive browser features by tracking and enforcing permissions granted to specific origins or sites based on user interaction.
  • Session and Credential Management - Handles identity and authentication tokens across different domains to facilitate secure user logins and session persistence.
  • Rendering Pipelines - Decouples visual updates from the main thread by managing hardware-accelerated layers to maintain fluid scrolling and animation performance.
  • Automated End-to-End Testing - Executes automated test suites to verify browser rendering, engine logic, and user interface interactions.
  • Browser Automation Testing - Implements comprehensive browser automation protocols to execute large-scale test suites and fuzzing workflows.
  • Browser Interface Enhancements - Provides an interface for third-party modules to modify browser behavior and add custom features.
  • Input-Decoupled Rendering Optimizers - Enables responsive navigation by decoupling input handling from main rendering cycles, allowing for smooth updates to page offsets without full re-renders.
  • Browser Automation - Provides a suite of tools and protocols for controlling browser instances and executing automated workflows.
  • Client-Side Execution Environments - Runs dynamic code within a sandboxed environment to enable interactive web applications.
  • Browser Isolation Strategies - Distributes web content and browser tasks across multiple system processes to improve stability and prevent site-specific failures from crashing the application.
  • Web Standards - Provides a comprehensive suite of modules that interpret and render HTML, CSS, and DOM specifications.
  • Debugging and Inspection Tools - Offers a suite of diagnostic tools to analyze network traffic, debug scripts, and profile performance during web development.
  • JavaScript and TypeScript Debugging - Includes specialized tools for stepping through, inspecting, and profiling JavaScript code within the browser.
  • Performance Profiling - Includes comprehensive tools for measuring site responsiveness, layout rendering, and memory usage.
  • Dynamic Feature Flag Systems - Updates application settings and feature flags dynamically from a remote server without requiring a full software update or client-side deployment.
  • Application Update Managers - Checks for and installs software updates to ensure users receive the latest security patches and feature improvements.
  • Compositors - Coordinates the rendering of visual elements by managing layers and hardware-accelerated buffers to display complex web pages and media.
  • Media Decoders - Decodes and displays audio and video streams using platform-specific hardware and software codecs.
  • Secure Resolvers - Encrypts domain name lookups using a trusted recursive resolver to prevent third parties from intercepting or tampering with web traffic navigation.
  • Network Traffic Proxying - Routes network traffic through proxy servers to hide the user's original IP address from websites and online services.
  • Network Traffic Analyzers - Monitors all network requests and responses made by a web page to diagnose loading issues and performance bottlenecks.
  • Cross-Language Bindings Layers - Provides a formal binding layer that connects high-level scripting environments with low-level system logic.
  • Just-In-Time Compilers - Converts source scripts into optimized machine instructions at runtime to increase execution speed based on frequently called function patterns.
  • Parallel Style Calculators - Distributes the computation of element styles across multiple processor cores to accelerate the rendering of web pages and improve responsiveness.
  • Content Filtering and Blocking - Filters out trackers, advertisements, and malicious scripts to enhance privacy and performance.
  • Memory Compartment Access Validators - Determines security relationships between memory regions by evaluating whether the principal of one compartment subsumes the principal of another.
  • Cross-Privilege Object Sanitizers - Provides privileged code with a native, unmodified view of objects created by untrusted content to prevent manipulation of standard properties or methods.
  • Secure Multi-Device Synchronization - Replicates bookmarks, history, and preferences across multiple devices by securely encrypting and syncing local state.
  • Cryptographic Standards - Provides a library for applications to support industry-standard security protocols including TLS, SSL, and PKCS specifications.
  • Desktop Graphics Abstractions - Provides a unified interface for 2D drawing commands that translates into platform-specific backend calls for consistent rendering across operating systems.
  • Memory Safety Validators - Validates pointer lifecycles during layout operations to ensure objects are not destroyed while still in use by the rendering engine.
  • Sandboxed Execution Environments - Provides a security-hardened, isolated runtime environment for executing untrusted web content and scripts.
  • Web Testing Frameworks - Runs standardized test suites against the browser to verify compliance with web specifications and identify regressions in rendering or functionality.
  • Unit Testing Frameworks - Provides comprehensive frameworks for executing automated unit tests to verify core logic.
  • Interface Frameworks - Provides a customizable user interface framework for toolbars, menus, and panels that allows for dynamic layout adjustments and component integration.
  • Declarative UI Frameworks - Builds user interface elements using reactive properties and shadow DOM encapsulation to ensure consistent rendering and modular feature development.
  • Cross-Platform UI Frameworks - Employs a declarative component framework to build and style browser interfaces across multiple platforms.
  • CSS Styling - Parses CSS rules and presentation attributes to calculate the final visual properties for each document node based on the CSS cascade.
  • Layout Engines - Calculates the visual geometry and positioning of elements on a page based on style rules to display content correctly.
  • Browser Extensions - Provides comprehensive management for installing, updating, and removing browser extensions.
  • State Persistence Managers - Maintains user profiles, history, bookmarks, and session data to provide a persistent and personalized browsing experience.
  • Browser Scripting Tools - Executes code within web pages and browser interface components to enable dynamic behavior.
  • Context Isolation Managers - Isolates browsing contexts to prevent data leakage between different tabs or windows and ensures independent state management for each session.
  • Fetch API Integrations - Implements secure network request handling for fetching web content and domain records.
  • Style Cascading Engines - Processes style definitions and cascades them onto document elements to determine their visual appearance and presentation on the screen.
  • Oblivious Resource Loaders - Fetches web resources through an oblivious HTTP protocol to protect user privacy while accessing content from privileged browser contexts.
  • Rendering and Visualization - Transforms document structures and style data into a frame tree for visual presentation.
  • Browser Bookmark Managers - Maintains a persistent collection of saved web page links in a structured database.
  • Automated Test Execution - Executes browser-based tests to verify application logic and user interface components.
  • Continuous Integration - Orchestrates complex task graphs to automate building and testing workflows within continuous integration pipelines.
  • Rendering Backends - Abstracts drawing operations to support multiple backends including hardware-accelerated rendering, software-based rasterization, and document printing.
  • Inter-Process Communication - Facilitates secure message exchange between the main browser process and content processes.
  • Process Lifecycle Managers - Orchestrates the creation, monitoring, and orderly shutdown of browser processes.
  • Memory Safety Diagnostics - Identifies use-after-free and out-of-bounds access bugs by instrumenting memory operations.
  • C++ Bindings - Exposes Rust functionality to C++ codebases to enable memory-safe performance improvements.
  • Rust - Incorporates shared application logic written in Rust to handle cross-platform features like account authentication and experiment management.
  • Browser Security Policies - Enforces organizational security policies and operational standards across managed browser instances.
  • Command Injection Prevention - Validates and cleans untrusted command line arguments from external applications to prevent malicious parameter injection.
  • Cross-Origin Resource Sharing Policies - Restricts access between web objects based on their origin to prevent unauthorized interaction between different websites.
  • Execution Isolation - Allocates separate memory compartments for global objects to ensure that code execution remains contained.
  • Security Context Managers - Coordinates the lifecycle and hierarchy of web page containers to ensure secure and isolated execution.
  • Event Bus Architectures - Facilitates communication between decoupled system components using a publish-subscribe mechanism to coordinate state without requiring direct dependencies.
  • Inter-Process Communication - Implements secure message passing between browser processes to coordinate actions and share data.
  • Frame Tree Generators - Transforms a document content tree into a structured frame tree by mapping nodes to visual elements based on style data and structural requirements.
  • Crash Reporting - Stores and retrieves statistical and detailed information about browser and content process crashes to facilitate analysis and troubleshooting.
  • Application Performance Profiling - Records and analyzes execution behavior to identify bottlenecks and measure the performance of web applications or browser components.
  • Browsing Profile Containers - Organizes user data into distinct containers to keep browsing history, bookmarks, and settings isolated between different sessions or users.
  • Execution Profilers - Captures runtime execution data using system-level profilers and telemetry probes to identify bottlenecks in code and JIT compilation.
  • Automated Regression Verification - Triggers verification tasks automatically upon code changes to identify potential test regressions in continuous integration pipelines.
  • Cross-Browser Testing Tools - Executes standardized test suites across multiple browser engines to compare behavior and identify inconsistencies in web platform implementation.
  • Accessibility Auditing Tools - Examines the accessibility tree to identify missing attributes or structural issues that impact screen readers.
  • Coordinate Transform Hierarchies - Maintains a hierarchy of coordinate transforms to accurately position and scale page elements relative to their parents and the final device display.
  • Dynamic Rendering Updaters - Updates the visual representation of a page in real time as document structure or style properties change during user interaction.
  • Asynchronous Input Handlers - Decouples input handling from the main thread to allow fluid scrolling and zooming interactions even when the page content is busy.
  • Compositor-Thread Scrolling Testers - Tests asynchronous scrolling, zooming, and displayport dimensions to verify compositor-thread behavior during complex rendering operations.
  • Address Bar Navigators - Processes user input to load web addresses and provides predictive suggestions based on browsing history, bookmarks, and configured search engines.
  • Pipeline Optimizers - Batches DOM, style, and layout updates to minimize redundant processing while ensuring scripts perceive changes as immediate.
  • Cascading Style Sheets - Parses style sheets to determine the appearance and layout properties of every element within a document.
  • UI Components - Displays standardized interface elements across the browser to maintain consistent visual patterns and interaction behaviors.
  • Preference Sanitization Engines - Sanitizes and blocks sensitive preferences from entering subprocesses to protect user privacy and reduce inter-process communication overhead.
  • Component-Based Page Layouts - Offers real-time inspection and modification of page structure, styles, and layout properties.
  • Development Frameworks - Provides a robust framework and API surface for third-party developers to build and manage browser extensions.
  • Browser History Management - Stores and organizes records of visited web pages in a centralized database to enable efficient retrieval.
  • Tab Lifecycle Controllers - Controls the lifecycle of web pages within a window by providing methods to add, remove, and switch between multiple active browsing sessions.
  • Machine Learning Engines - Provides a local runtime engine for executing machine learning models directly within the browser.
  • Performance Regression Analyzers - Executes automated test suites to identify and track changes in speed, memory usage, and responsiveness across different code commits.
  • Browser Storage Managers - Provides tools for inspecting and managing client-side storage like cookies, local storage, and indexed databases.
  • Embedded Databases - Provides interfaces for interacting with local storage engines like SQLite to persist application data.
  • Search Interface Components - Displays search bars and one-off search buttons within the browser toolbar and content areas to facilitate user navigation.
  • Browsing Data Search Aggregators - Aggregates results from history, bookmarks, open tabs, search engines, and extensions into a single interface to help users navigate to specific content.
  • Performance Benchmarks - Measures and reports the execution duration of specific code units to track performance metrics and identify regressions during the development process.
  • Search Engine Configuration - Manages a collection of search providers based on user locale and region, allowing users to designate specific engines for standard and private browsing.
  • Render Pass Effect Pipelines - Breaks down advanced graphical requirements like shadows, blurs, and filters into sequences of render passes to ensure accurate visual output.
  • Web Push Notification Receivers - Subscribes to remote services via persistent web sockets to receive and decrypt background messages for web applications.
  • Memory Management Systems - Identifies and releases unused objects to reclaim system memory and prevent long-term performance degradation.
  • Uninitialized Memory Detectors - Verifies that all memory reads originate from previously initialized locations to prevent undefined behavior.
  • Background Task Management - Executes scripts and data operations in separate threads to maintain interface responsiveness.
  • Binding Configurations - Maps native classes to web-facing interfaces by defining binding configurations to connect the engine with web content.
  • Platform Feature Access Controllers - Limits browser capabilities on Windows systems by requiring specific authorization or configuration steps to unlock restricted operating system integrations and features.
  • Security Context Definitions - Assigns specific security identities to web content, browser UI, and extensions to govern access permissions and resource isolation.
  • Script Execution Isolators - Isolates execution environments and validates cross-origin interactions to prevent unauthorized access between different web pages.
  • Fuzzing Tools - Performs fuzzing on the entire browser environment to identify stability issues in complex features.
  • Session Synchronization - Saves the state of open windows and tabs to restore them automatically after restarts.
  • Document Object Interfaces - Provides interfaces for manipulating web page elements and internal components through standardized object definitions.
  • Background Thread Dispatchers - Executes JavaScript tasks in background threads to maintain UI responsiveness during intensive operations.
  • Process Coordinators - Coordinates state and messaging between different browser processes to ensure consistent behavior.
  • Compositor Synchronization - Manages communication between the main process and the compositor thread to ensure visual updates remain responsive during heavy workloads.
  • Decoupled Architectures - Uses publish-subscribe mechanisms to decouple system components and minimize direct dependencies.
  • Application Performance Monitoring Platforms - Tracks and logs application crashes to identify performance regressions and facilitate debugging of stability issues.
  • Crash Reporters - Records process state, stack traces, and memory reports during crashes or hangs to facilitate debugging and performance analysis.
  • Layout Inspection Overlays - Displays internal rendering data including matched CSS rules, text runs, and frame structures to help developers diagnose visual layout issues.
  • Memory Usage Analyzers - Tracks and records memory consumption patterns across various builds to detect leaks or inefficient resource allocation over time.
  • Concurrency Analyzers - Identify non-race-free operations and synchronization issues by monitoring memory access patterns across multiple threads during program execution to prevent unpredictable state changes.
  • Color Themes - Switches interface color schemes between light, dark, or platform-specific styles to match user preferences.
  • Design Systems - Adjusts interface design tokens automatically based on system-level contrast settings and forced color modes.
  • Element Positioning Utilities - Calculates the precise position and dimensions of visual frames recursively to determine the final layout of a page based on style constraints.
  • Reusable UI Components - Provides a framework for building reusable UI components with reactive properties and shadow DOM encapsulation.
  • Mobile Web Embedding Engines - Renders web pages within mobile applications using a self-contained engine that ensures consistent behavior across different devices and operating system versions.
  • Isolated Browser Contexts - Executes specialized interface components within a restricted per-origin scope to separate their logic from the main browser chrome.
  • Preference - Registers callbacks or observers to trigger logic automatically whenever a specific preference or a group of preferences matching a prefix is modified.
  • Validated Web Forms - Automatically populates web forms by matching input fields against stored user profile data.
  • User Interface Localization - Adapts software text, date formats, and cultural conventions to match the user's specific language and regional settings for a consistent experience.
  • Initial Page Load Optimizations - Processes early server hints to initiate resource fetching before the final document is fully parsed, reducing the time required to render web content.
  • Rich Text Editors - Provides rich text formatting capabilities for editable web content with shared undo/redo history.
  • Smooth Scroll Engines - Maintains persistent layer buffers and tiled textures to enable smooth navigation and reduce the computational cost of frequent screen updates.
  • Web Inspection Utilities - Examines the structure, styles, and layout of web pages in real-time to assist with debugging and design adjustments.
  • Layout Fragmentation Handlers - Splits visual content across multiple pages or columns to support printing, print-preview, and multi-column layout requirements.
  • Automated Translators - Converts text on web pages into different languages automatically to improve accessibility.
  • Script Compilation - Converts source scripts into executable bytecode using lazy parsing to optimize function execution.
  • HTTP Caching - Stores and reuses network responses locally to minimize redundant data requests and ensure content remains accurate.
  • Local Data Stores - Persists history and bookmarks in a local database for efficient retrieval.
  • Asynchronous Streams - Provides standardized interfaces for handling asynchronous data streams to enable efficient, progressive processing of web content.
  • Test Execution and Management - Attaches external debuggers to test processes to inspect state, manage breakpoints, and troubleshoot failures during the execution of automated test suites.
  • Regression Identifiers - Flags failures that have not been seen in recent history to help developers isolate potential new issues from known intermittent test noise.
  • Responsive Development Environments - Allows developers to preview how web content renders across various screen sizes and device types.
  • Search Provider Configurators - Maintains a configurable list of search providers to facilitate web queries directly from the browser interface.
  • Update Integrity Validators - Validates that applying an update archive results in the same file state as a fresh installation to ensure update reliability.
  • Asynchronous Shutdown Coordination - Blocks process termination until registered asynchronous tasks complete, allowing background operations to finish without stalling the main thread during the shutdown sequence.
  • Lifecycle Cleanup Callbacks - Registers callbacks or clears memory references during specific application lifecycle phases to ensure resources are released gracefully when the process terminates.
  • Version Upgrades - Forces updates through specific milestone versions when necessary to prepare the system for final upgrades.
  • Contextual - Routes and displays contextual messages or UI notifications to users based on defined system events and communication templates.
  • Operating System Kernels - Provides platform-neutral interfaces for low-level system functions to ensure consistent behavior across operating systems.
  • Native macOS API Bridges - Interfaces with platform-specific system frameworks to provide native windowing, event handling, and hardware acceleration features on Apple hardware.
  • Editor Content Synchronizers - Maintains a cache of editor content and selection state across process boundaries to allow input methods to query and modify text without synchronous communication.
  • Rust-Implemented Tools - Implements modular system components in Rust to enhance performance and memory safety.
  • Object Lifetime Management - Tracks object references and memory usage to prevent leaks and ensure resources are cleaned up.
  • Security Policy Enforcers - Validates network requests against origin policies, content restrictions, and secure transport requirements before execution.
  • Multi-Device Synchronization - Propagates specific user settings to other devices by enabling synchronization flags.
  • Third-Party Authentication Providers - Facilitates secure user sign-in across websites by mediating communication between identity providers and relying parties.
  • Experimentation Frameworks - Deploys feature flags and configuration changes to specific user segments to test new functionality and gather data.
  • Development Tool Extenders - Registers custom actors and interfaces to add specialized debugging and inspection tools to the development environment.
  • Code Optimization - Compiles frequently used code into specialized machine instructions to increase processing efficiency.
  • Crash History Managers - Displays a list of past application crashes and their submission status within a dedicated internal interface.
  • Process Monitors - Displays real-time statistics and the distribution of web pages across active browser processes to help identify performance bottlenecks or memory consumption.
  • System Performance Analyzers - Captures statistical samples of thread execution including native, JavaScript, and custom stack frames to identify performance bottlenecks.
  • Code Coverage Tools - Instruments builds to track which lines of code are executed during testing, generating reports to identify untested areas or dead code.
  • Test Isolation - Ensures test execution environments remain independent by running logic within isolated child processes.
  • Unit Testing - Runs isolated unit tests for components without requiring platform-specific dependencies.
  • Accessible Document Creation - Produces structured, semantically rich documents to ensure compatibility with assistive technologies.
  • Color Rendering Adjustments - Adjusts visual color rendering and styles to improve readability for users with visual impairments.
  • Form and Input Management - Captures and stores user input to streamline form submission across different websites.
  • Input Event Dispatchers - Standardizes the translation of native platform input events into internal composition and keyboard events to ensure consistent text entry behavior.
  • Form Management - Automates the entry of passwords, addresses, and payment information into web forms using background providers.
  • Input Method Editors - Coordinates with the operating system to enable or disable text input methods based on the focus state of web elements and editor requirements.
  • UI Customization Tools - Manages the placement, visibility, and arrangement of UI widgets across toolbars, panels, and menus.
  • Browser Data Persistence - Stores and retrieves persistent data locally to support offline web application functionality.
  • Browser Session Managers - Isolates web application data into distinct containers to maintain session privacy and security.
  • Asynchronous Data Handling - Coordinates non-blocking asynchronous operations through callback chaining and state management.
  • Undo-Redo History - Records individual DOM updates as reversible actions to enable undo and redo functionality.
  • Real-Time Communication - Enables persistent, bidirectional data streaming between the browser and external clients for real-time event handling.
  • Remote Debugging Tools - Provides interfaces for connecting development environments to live browser sessions for debugging and inspection.
  • Response Streaming Interfaces - Processes data chunks incrementally using standardized interfaces for improved performance.
  • Dependency Management - Tracks upstream source versions and applies custom patches to integrated external code during the build process.
  • Browser Configuration Profiles - Manages isolated browser environments and settings to ensure consistent states during automated testing.

    • Historique des stars

    Graphique de l'historique des stars pour mozilla-firefox/firefoxGraphique de l'historique des stars pour mozilla-firefox/firefox

    Alternatives open source à Firefox

    Projets open source similaires, classés selon le nombre de fonctionnalités partagées avec Firefox.
    • waterfoxco/waterfoxAvatar de WaterfoxCo

      WaterfoxCo/Waterfox

      6,001Voir sur GitHub↗

      Waterfox is a cross-platform web browser built on the Firefox engine. It functions as a privacy-focused browsing platform designed to render web content and navigate the internet across multiple operating systems. The browser is distinguished by its removal of telemetry and tracking to prevent data collection and user profiling. It maintains compatibility with both modern and classic browser extensions, allowing users to modify functionality and the visual user interface. The project covers broad capabilities in cross-platform web rendering and customizable browser experiences, utilizing a b

      JavaScript
      Voir sur GitHub↗6,001
    • ariya/phantomjsAvatar de ariya

      ariya/phantomjs

      29,489Voir sur GitHub↗

      PhantomJS is a scriptable, headless browser engine based on WebKit that provides a programmatic interface for automating web page interactions. It operates without a graphical user interface, allowing for the execution of JavaScript to navigate pages, manipulate the document object model, and perform functional testing of web applications. The tool distinguishes itself by providing low-level control over the browser rendering lifecycle and network stack. It enables real-time interception and modification of network traffic, alongside the ability to generate visual snapshots and document expor

      C++automationheadlessheadless-browser
      Voir sur GitHub↗29,489
    • brave/brave-browserAvatar de brave

      brave/brave-browser

      21,691Voir sur GitHub↗

      Brave is a privacy-centric web browser built on the Chromium engine. It functions as a cross-platform navigation tool designed to protect user data by automatically blocking trackers and advertisements by default. The browser distinguishes itself through integrated search capabilities that allow for programmatic control over query execution and data retrieval. It provides a platform for custom search engine development, enabling users to apply specific ranking rules, filter content based on geographic or temporal constraints, and enrich results with real-time structured data. Beyond its core

      bravebrowserchromium
      Voir sur GitHub↗21,691
    • chromium/chromiumAvatar de chromium

      chromium/chromium

      22,997Voir sur GitHub↗

      Chromium is an open-source browser platform that provides the foundational codebase for building cross-platform web browsers. At its core, it functions as a web browser engine that interprets standard web technologies to render interactive content and manage the complex lifecycle of web page navigation. The project utilizes a multi-process architecture that separates the browser interface from rendering engines into distinct operating system processes. This design ensures application stability by preventing a single tab crash from affecting the entire browser. Security is maintained through s

      C++
      Voir sur GitHub↗22,997
    Voir les 30 alternatives à Firefox→

    Questions fréquentes

    Que fait mozilla-firefox/firefox ?

    Firefox is a cross-platform web browser engine designed to render web content, execute JavaScript, and manage secure browsing sessions. It utilizes a multi-process isolation architecture that distributes browser tasks across independent operating system processes to ensure stability and prevent site-specific failures from impacting the entire application. The engine incorporates a sandboxed execution environment to restrict web content and untrusted scripts to isolated…

    Quelles sont les fonctionnalités principales de mozilla-firefox/firefox ?

    Les fonctionnalités principales de mozilla-firefox/firefox sont : Script Execution Contexts, Privacy Protection, Web Applications, Process Isolation Architectures, Browser Engines, Web Rendering Engines, Isolated Tab Rendering, Privacy-Focused Web Browsers.

    Quelles sont les alternatives open-source à mozilla-firefox/firefox ?

    Les alternatives open-source à mozilla-firefox/firefox incluent : waterfoxco/waterfox — Waterfox is a cross-platform web browser built on the Firefox engine. It functions as a privacy-focused browsing… ariya/phantomjs — PhantomJS is a scriptable, headless browser engine based on WebKit that provides a programmatic interface for… brave/brave-browser — Brave is a privacy-centric web browser built on the Chromium engine. It functions as a cross-platform navigation tool… chromium/chromium — Chromium is an open-source browser platform that provides the foundational codebase for building cross-platform web… mherrmann/selenium-python-helium — This project is a high-level Python library and wrapper for Selenium designed for web browser automation and… adguardteam/adguardfilters — AdguardFilters is a collection of curated adblock filter lists, content blocking rulesets, and DNS blocklists. Its…