Markdown on Producthunt daily

firecrawl

Fri, 22 Aug 2025 15:27:47 +0800

firecrawl/firecrawl

🔥 Firecrawl

Empower your AI apps with clean data from any website. Featuring advanced scraping, crawling, and data extraction capabilities.

This repository is in development, and we’re still integrating custom modules into the mono repo. It’s not fully ready for self-hosted deployment yet, but you can run it locally.

What is Firecrawl?

Firecrawl is an API service that takes a URL, crawls it, and converts it into clean markdown or structured data. We crawl all accessible subpages and give you clean data for each. No sitemap required. Check out our documentation.

Pst. hey, you, join our stargazers :)

How to use it?

We provide an easy to use API with our hosted version. You can find the playground and documentation here. You can also self host the backend if you’d like.

Check out the following resources to get started:

API: Documentation
SDKs: Python, Node
LLM Frameworks: Langchain (python), Langchain (js), Llama Index, Crew.ai, Composio, PraisonAI, Superinterface, Vectorize
Low-code Frameworks: Dify, Langflow, Flowise AI, Cargo, Pipedream
Community SDKs: Go, Rust
Others: Zapier, Pabbly Connect
Want an SDK or Integration? Let us know by opening an issue.

To run locally, refer to guide here.

API Key

To use the API, you need to sign up on Firecrawl and get an API key.

Features

Scrape: scrapes a URL and get its content in LLM-ready format (markdown, structured data via LLM Extract, screenshot, html)
Crawl: scrapes all the URLs of a web page and return content in LLM-ready format
Map: input a website and get all the website urls - extremely fast
Search: search the web and get full content from results
Extract: get structured data from single page, multiple pages or entire websites with AI.

Powerful Capabilities

LLM-ready formats: markdown, structured data, screenshot, HTML, links, metadata
The hard stuff: proxies, anti-bot mechanisms, dynamic content (js-rendered), output parsing, orchestration
Customizability: exclude tags, crawl behind auth walls with custom headers, max crawl depth, etc…
Media parsing: pdfs, docx, images
Reliability first: designed to get the data you need - no matter how hard it is
Actions: click, scroll, input, wait and more before extracting data
Batching (New): scrape thousands of URLs at the same time with a new async endpoint.

You can find all of Firecrawl’s capabilities and how to use them in our documentation

Crawling

Used to crawl a URL and all accessible subpages. This submits a crawl job and returns a job ID to check the status of the crawl.

curl -X POST https://api.firecrawl.dev/v2/crawl \
    -H 'Content-Type: application/json' \
    -H 'Authorization: Bearer fc-YOUR_API_KEY' \
    -d '{
      "url": "https://docs.firecrawl.dev",
      "limit": 10,
      "scrapeOptions": {
        "formats": ["markdown", "html"]
      }
    }'

Returns a crawl job id and the url to check the status of the crawl.

{
  "success": true,
  "id": "123-456-789",
  "url": "https://api.firecrawl.dev/v2/crawl/123-456-789"
}

Check Crawl Job

Used to check the status of a crawl job and get its result.

1
2
3

curl -X GET https://api.firecrawl.dev/v2/crawl/123-456-789 \
  -H 'Content-Type: application/json' \
  -H 'Authorization: Bearer YOUR_API_KEY'

{
  "status": "completed",
  "total": 36,
  "creditsUsed": 36,
  "expiresAt": "2024-00-00T00:00:00.000Z",
  "data": [
    {
      "markdown": "[Firecrawl Docs home page![light logo](https://mintlify.s3-us-west-1.amazonaws.com/firecrawl/logo/light.svg)!...",
      "html": "<!DOCTYPE html><html lang=\"en\" class=\"js-focus-visible lg:[--scroll-mt:9.5rem]\" data-js-focus-visible=\"\">...",
      "metadata": {
        "title": "Build a 'Chat with website' using Groq Llama 3 | Firecrawl",
        "language": "en",
        "sourceURL": "https://docs.firecrawl.dev/learn/rag-llama3",
        "description": "Learn how to use Firecrawl, Groq Llama 3, and Langchain to build a 'Chat with your website' bot.",
        "ogLocaleAlternate": [],
        "statusCode": 200
      }
    }
  ]
}

Scraping

Used to scrape a URL and get its content in the specified formats.

curl -X POST https://api.firecrawl.dev/v2/scrape \
    -H 'Content-Type: application/json' \
    -H 'Authorization: Bearer YOUR_API_KEY' \
    -d '{
      "url": "https://docs.firecrawl.dev",
      "formats" : ["markdown", "html"]
    }'

Response:

{
  "success": true,
  "data": {
    "markdown": "Launch Week I is here! [See our Day 2 Release 🚀](https://www.firecrawl.dev/blog/launch-week-i-day-2-doubled-rate-limits)[💥 Get 2 months free...",
    "html": "<!DOCTYPE html><html lang=\"en\" class=\"light\" style=\"color-scheme: light;\"><body class=\"__variable_36bd41 __variable_d7dc5d font-inter ...",
    "metadata": {
      "title": "Home - Firecrawl",
      "description": "Firecrawl crawls and converts any website into clean markdown.",
      "language": "en",
      "keywords": "Firecrawl,Markdown,Data,Mendable,Langchain",
      "robots": "follow, index",
      "ogTitle": "Firecrawl",
      "ogDescription": "Turn any website into LLM-ready data.",
      "ogUrl": "https://www.firecrawl.dev/",
      "ogImage": "https://www.firecrawl.dev/og.png?123",
      "ogLocaleAlternate": [],
      "ogSiteName": "Firecrawl",
      "sourceURL": "https://firecrawl.dev",
      "statusCode": 200
    }
  }
}

Map

Used to map a URL and get urls of the website. This returns most links present on the website.

curl -X POST https://api.firecrawl.dev/v2/map \
    -H 'Content-Type: application/json' \
    -H 'Authorization: Bearer YOUR_API_KEY' \
    -d '{
      "url": "https://firecrawl.dev"
    }'

Response:

{
  "success": true,
  "links": [
    { "url": "https://firecrawl.dev", "title": "Firecrawl", "description": "Firecrawl is a tool that allows you to crawl a website and get the data you need." },
    { "url": "https://www.firecrawl.dev/pricing", "title": "Firecrawl Pricing", "description": "Firecrawl Pricing" },
    { "url": "https://www.firecrawl.dev/blog", "title": "Firecrawl Blog", "description": "Firecrawl Blog" },
    { "url": "https://www.firecrawl.dev/playground", "title": "Firecrawl Playground", "description": "Firecrawl Playground" },
    { "url": "https://www.firecrawl.dev/smart-crawl", "title": "Firecrawl Smart Crawl", "description": "Firecrawl Smart Crawl" }
  ]
}

Map with search

Map with search param allows you to search for specific urls inside a website.

curl -X POST https://api.firecrawl.dev/v2/map \
    -H 'Content-Type: application/json' \
    -H 'Authorization: Bearer YOUR_API_KEY' \
    -d '{
      "url": "https://firecrawl.dev",
      "search": "docs"
    }'

Response will be an ordered list from the most relevant to the least relevant.

{
  "success": true,
  "links": [
    { "url": "https://docs.firecrawl.dev", "title": "Firecrawl Docs", "description": "Firecrawl Docs" },
    { "url": "https://docs.firecrawl.dev/sdks/python", "title": "Firecrawl Python SDK", "description": "Firecrawl Python SDK" },
    { "url": "https://docs.firecrawl.dev/learn/rag-llama3", "title": "Firecrawl RAG Llama 3", "description": "Firecrawl RAG Llama 3" }
  ]
}

Search

Search the web and get full content from results

Firecrawl’s search API allows you to perform web searches and optionally scrape the search results in one operation.

Choose specific output formats (markdown, HTML, links, screenshots)
Search the web with customizable parameters (language, country, etc.)
Optionally retrieve content from search results in various formats
Control the number of results and set timeouts

curl -X POST https://api.firecrawl.dev/v2/search \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer fc-YOUR_API_KEY" \
  -d '{
    "query": "what is firecrawl?",
    "limit": 5
  }'

Response

{
  "success": true,
  "data": [
    {
      "url": "https://firecrawl.dev",
      "title": "Firecrawl | Home Page",
      "description": "Turn websites into LLM-ready data with Firecrawl"
    },
    {
      "url": "https://docs.firecrawl.dev",
      "title": "Documentation | Firecrawl",
      "description": "Learn how to use Firecrawl in your own applications"
    }
  ]
}

With content scraping

curl -X POST https://api.firecrawl.dev/v2/search \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer fc-YOUR_API_KEY" \
  -d '{
    "query": "what is firecrawl?",
    "limit": 5,
    "scrapeOptions": {
      "formats": ["markdown", "links"]
    }
  }'

Extract (Beta)

Get structured data from entire websites with a prompt and/or a schema.

You can extract structured data from one or multiple URLs, including wildcards:

Single Page: Example: https://firecrawl.dev/some-page

Multiple Pages / Full Domain Example: https://firecrawl.dev/*

When you use /*, Firecrawl will automatically crawl and parse all URLs it can discover in that domain, then extract the requested data.

curl -X POST https://api.firecrawl.dev/v2/extract \
    -H 'Content-Type: application/json' \
    -H 'Authorization: Bearer YOUR_API_KEY' \
    -d '{
      "urls": [
        "https://firecrawl.dev/*", 
        "https://docs.firecrawl.dev/", 
        "https://www.ycombinator.com/companies"
      ],
      "prompt": "Extract the company mission, whether it is open source, and whether it is in Y Combinator from the page.",
      "schema": {
        "type": "object",
        "properties": {
          "company_mission": {
            "type": "string"
          },
          "is_open_source": {
            "type": "boolean"
          },
          "is_in_yc": {
            "type": "boolean"
          }
        },
        "required": [
          "company_mission",
          "is_open_source",
          "is_in_yc"
        ]
      }
    }'

{
  "success": true,
  "id": "44aa536d-f1cb-4706-ab87-ed0386685740",
  "urlTrace": []
}

If you are using the sdks, it will auto pull the response for you:

{
  "success": true,
  "data": {
    "company_mission": "Firecrawl is the easiest way to extract data from the web. Developers use us to reliably convert URLs into LLM-ready markdown or structured data with a single API call.",
    "supports_sso": false,
    "is_open_source": true,
    "is_in_yc": true
  }
}

LLM Extraction (Beta)

Used to extract structured data from scraped pages.

curl -X POST https://api.firecrawl.dev/v2/scrape \
  -H 'Content-Type: application/json' \
  -H 'Authorization: Bearer YOUR_API_KEY' \
  -d '{
    "url": "https://www.mendable.ai/",
    "formats": [
      {
        "type": "json",
        "schema": {
          "type": "object",
          "properties": {
            "company_mission": { "type": "string" },
            "supports_sso": { "type": "boolean" },
            "is_open_source": { "type": "boolean" },
            "is_in_yc": { "type": "boolean" }
          }
        }
      }
    ]
  }'

{
  "success": true,
  "data": {
    "content": "Raw Content",
    "metadata": {
      "title": "Mendable",
      "description": "Mendable allows you to easily build AI chat applications. Ingest, customize, then deploy with one line of code anywhere you want. Brought to you by SideGuide",
      "robots": "follow, index",
      "ogTitle": "Mendable",
      "ogDescription": "Mendable allows you to easily build AI chat applications. Ingest, customize, then deploy with one line of code anywhere you want. Brought to you by SideGuide",
      "ogUrl": "https://mendable.ai/",
      "ogImage": "https://mendable.ai/mendable_new_og1.png",
      "ogLocaleAlternate": [],
      "ogSiteName": "Mendable",
      "sourceURL": "https://mendable.ai/"
    },
    "json": {
      "company_mission": "Train a secure AI on your technical resources that answers customer and employee questions so your team doesn't have to",
      "supports_sso": true,
      "is_open_source": false,
      "is_in_yc": true
    }
  }
}

Extracting without a schema (New)

You can now extract without a schema by just passing a prompt to the endpoint. The llm chooses the structure of the data.

curl -X POST https://api.firecrawl.dev/v2/scrape \
    -H 'Content-Type: application/json' \
    -H 'Authorization: Bearer YOUR_API_KEY' \
    -d '{
      "url": "https://docs.firecrawl.dev/",
      "formats": [
        {
          "type": "json",
          "prompt": "Extract the company mission from the page."
        }
      ]
    }'

Interacting with the page with Actions (Cloud-only)

Firecrawl allows you to perform various actions on a web page before scraping its content. This is particularly useful for interacting with dynamic content, navigating through pages, or accessing content that requires user interaction.

Here is an example of how to use actions to navigate to google.com, search for Firecrawl, click on the first result, and take a screenshot.

curl -X POST https://api.firecrawl.dev/v2/scrape \
    -H 'Content-Type: application/json' \
    -H 'Authorization: Bearer YOUR_API_KEY' \
    -d '{
        "url": "google.com",
        "formats": ["markdown"],
        "actions": [
            {"type": "wait", "milliseconds": 2000},
            {"type": "click", "selector": "textarea[title=\"Search\"]"},
            {"type": "wait", "milliseconds": 2000},
            {"type": "write", "text": "firecrawl"},
            {"type": "wait", "milliseconds": 2000},
            {"type": "press", "key": "ENTER"},
            {"type": "wait", "milliseconds": 3000},
            {"type": "click", "selector": "h3"},
            {"type": "wait", "milliseconds": 3000},
            {"type": "screenshot"}
        ]
    }'

Batch Scraping Multiple URLs (New)

You can now batch scrape multiple URLs at the same time. It is very similar to how the /crawl endpoint works. It submits a batch scrape job and returns a job ID to check the status of the batch scrape.

curl -X POST https://api.firecrawl.dev/v2/batch/scrape \
    -H 'Content-Type: application/json' \
    -H 'Authorization: Bearer YOUR_API_KEY' \
    -d '{
      "urls": ["https://docs.firecrawl.dev", "https://docs.firecrawl.dev/sdks/overview"],
      "formats" : ["markdown", "html"]
    }'

Using Python SDK

Installing Python SDK

`1`	`pip install firecrawl-py`

Crawl a website

from firecrawl import Firecrawl

firecrawl = Firecrawl(api_key="fc-YOUR_API_KEY")

# Scrape a website (returns a Document)
doc = firecrawl.scrape(
    "https://firecrawl.dev",
    formats=["markdown", "html"],
)
print(doc.markdown)

# Crawl a website
response = firecrawl.crawl(
    "https://firecrawl.dev",
    limit=100,
    scrape_options={"formats": ["markdown", "html"]},
    poll_interval=30,
)
print(response)

Extracting structured data from a URL

With LLM extraction, you can easily extract structured data from any URL. We support pydantic schemas to make it easier for you too. Here is how you to use it:

from pydantic import BaseModel, Field
from typing import List

class Article(BaseModel):
    title: str
    points: int
    by: str
    commentsURL: str

class TopArticles(BaseModel):
    top: List[Article] = Field(..., description="Top 5 stories")

# Use JSON format with a Pydantic schema
doc = firecrawl.scrape(
    "https://news.ycombinator.com",
    formats=[{"type": "json", "schema": TopArticles}],
)
print(doc.json)

Using the Node SDK

Installation

To install the Firecrawl Node SDK, you can use npm:

`1`	`npm install @mendable/firecrawl-js`

Usage

Get an API key from firecrawl.dev
Set the API key as an environment variable named FIRECRAWL_API_KEY or pass it as a parameter to the Firecrawl class.

import Firecrawl from '@mendable/firecrawl-js';

const firecrawl = new Firecrawl({ apiKey: 'fc-YOUR_API_KEY' });

// Scrape a website
const doc = await firecrawl.scrape('https://firecrawl.dev', {
  formats: ['markdown', 'html'],
});
console.log(doc);

// Crawl a website
const response = await firecrawl.crawl('https://firecrawl.dev', {
  limit: 100,
  scrapeOptions: { formats: ['markdown', 'html'] },
});
console.log(response);

Extracting structured data from a URL

With LLM extraction, you can easily extract structured data from any URL. We support zod schema to make it easier for you too. Here is how to use it:

import Firecrawl from '@mendable/firecrawl-js';
import { z } from 'zod';

const firecrawl = new Firecrawl({ apiKey: 'fc-YOUR_API_KEY' });

// Define schema to extract contents into
const schema = z.object({
  top: z
    .array(
      z.object({
        title: z.string(),
        points: z.number(),
        by: z.string(),
        commentsURL: z.string(),
      })
    )
    .length(5)
    .describe('Top 5 stories on Hacker News'),
});

// Use the v2 extract API with direct Zod schema support
const extractRes = await firecrawl.extract({
  urls: ['https://news.ycombinator.com'],
  schema,
  prompt: 'Extract the top 5 stories',
});

console.log(extractRes);

Open Source vs Cloud Offering

Firecrawl is open source available under the AGPL-3.0 license.

To deliver the best possible product, we offer a hosted version of Firecrawl alongside our open-source offering. The cloud solution allows us to continuously innovate and maintain a high-quality, sustainable service for all users.

Firecrawl Cloud is available at firecrawl.dev and offers a range of features that are not available in the open source version:

Contributing

We love contributions! Please read our contributing guide before submitting a pull request. If you’d like to self-host, refer to the self-hosting guide.

It is the sole responsibility of the end users to respect websites’ policies when scraping, searching and crawling with Firecrawl. Users are advised to adhere to the applicable privacy policies and terms of use of the websites prior to initiating any scraping activities. By default, Firecrawl respects the directives specified in the websites’ robots.txt files when crawling. By utilizing Firecrawl, you expressly agree to comply with these conditions.

Contributors

License Disclaimer

This project is primarily licensed under the GNU Affero General Public License v3.0 (AGPL-3.0), as specified in the LICENSE file in the root directory of this repository. However, certain components of this project are licensed under the MIT License. Refer to the LICENSE files in these specific directories for details.

Please note:

The AGPL-3.0 license applies to all parts of the project unless otherwise specified.
The SDKs and some UI components are licensed under the MIT License. Refer to the LICENSE files in these specific directories for details.
When using or contributing to this project, ensure you comply with the appropriate license terms for the specific component you are working with.

For more details on the licensing of specific components, please refer to the LICENSE files in the respective directories or contact the project maintainers.

↑ Back to Top ↑

marker

Sat, 16 Aug 2025 15:27:34 +0800

datalab-to/marker

Marker

Marker converts documents to markdown, JSON, chunks, and HTML quickly and accurately.

Converts PDF, image, PPTX, DOCX, XLSX, HTML, EPUB files in all languages
Formats tables, forms, equations, inline math, links, references, and code blocks
Extracts and saves images
Removes headers/footers/other artifacts
Extensible with your own formatting and logic
Does structured extraction, given a JSON schema (beta)
Optionally boost accuracy with LLMs (and your own prompt)
Works on GPU, CPU, or MPS

Performance

Marker benchmarks favorably compared to cloud services like Llamaparse and Mathpix, as well as other open source tools.

The above results are running single PDF pages serially. Marker is significantly faster when running in batch mode, with a projected throughput of 25 pages/second on an H100.

See below for detailed speed and accuracy benchmarks, and instructions on how to run your own benchmarks.

Hybrid Mode

For the highest accuracy, pass the --use_llm flag to use an LLM alongside marker. This will do things like merge tables across pages, handle inline math, format tables properly, and extract values from forms. It can use any gemini or ollama model. By default, it uses gemini-2.0-flash. See below for details.

Here is a table benchmark comparing marker, gemini flash alone, and marker with use_llm:

As you can see, the use_llm mode offers higher accuracy than marker or gemini alone.

Examples

PDF	File type	Markdown	JSON
Think Python	Textbook	View	View
Switch Transformers	arXiv paper	View	View
Multi-column CNN	arXiv paper	View	View

Commercial usage

I want marker to be as widely accessible as possible, while still funding my development/training costs. Research and personal usage is always okay, but there are some restrictions on commercial usage.

The weights for the models are licensed cc-by-nc-sa-4.0, but I will waive that for any organization under $2M USD in gross revenue in the most recent 12-month period AND under $2M in lifetime VC/angel funding raised. You also must not be competitive with the Datalab API. If you want to remove the GPL license requirements (dual-license) and/or use the weights commercially over the revenue limit, check out the options here.

Hosted API

There’s a hosted API for marker available here:

Supports PDF, image, PPT, PPTX, DOC, DOCX, XLS, XLSX, HTML, EPUB files
1/4th the price of leading cloud-based competitors
Fast - ~15s for a 250 page PDF
Supports LLM mode
High uptime (99.99%)

Community

Discord is where we discuss future development.

Installation

You’ll need python 3.10+ and PyTorch.

Install with:

`1`	`pip install marker-pdf`

If you want to use marker on documents other than PDFs, you will need to install additional dependencies with:

`1`	`pip install marker-pdf[full]`

Usage

First, some configuration:

Your torch device will be automatically detected, but you can override this. For example, TORCH_DEVICE=cuda.
Some PDFs, even digital ones, have bad text in them. Set --force_ocr to force OCR on all lines, or the strip_existing_ocr to keep all digital text, and strip out any existing OCR text.
If you care about inline math, set force_ocr to convert inline math to LaTeX.

Interactive App

I’ve included a streamlit app that lets you interactively try marker with some basic options. Run it with:

1
2

pip install streamlit streamlit-ace
marker_gui

Convert a single file

`1`	`marker_single /path/to/file.pdf`

You can pass in PDFs or images.

Options:

--page_range TEXT: Specify which pages to process. Accepts comma-separated page numbers and ranges. Example: --page_range "0,5-10,20" will process pages 0, 5 through 10, and page 20.
--output_format [markdown|json|html|chunks]: Specify the format for the output results.
--output_dir PATH: Directory where output files will be saved. Defaults to the value specified in settings.OUTPUT_DIR.
--paginate_output: Paginates the output, using \n\n{PAGE_NUMBER} followed by - * 48, then \n\n
--use_llm: Uses an LLM to improve accuracy. You will need to configure the LLM backend - see below.
--force_ocr: Force OCR processing on the entire document, even for pages that might contain extractable text. This will also format inline math properly.
--block_correction_prompt: if LLM mode is active, an optional prompt that will be used to correct the output of marker. This is useful for custom formatting or logic that you want to apply to the output.
--strip_existing_ocr: Remove all existing OCR text in the document and re-OCR with surya.
--redo_inline_math: If you want the absolute highest quality inline math conversion, use this along with --use_llm.
--disable_image_extraction: Don’t extract images from the PDF. If you also specify --use_llm, then images will be replaced with a description.
--debug: Enable debug mode for additional logging and diagnostic information.
--processors TEXT: Override the default processors by providing their full module paths, separated by commas. Example: --processors "module1.processor1,module2.processor2"
--config_json PATH: Path to a JSON configuration file containing additional settings.
config --help: List all available builders, processors, and converters, and their associated configuration. These values can be used to build a JSON configuration file for additional tweaking of marker defaults.
--converter_cls: One of marker.converters.pdf.PdfConverter (default) or marker.converters.table.TableConverter. The PdfConverter will convert the whole PDF, the TableConverter will only extract and convert tables.
--llm_service: Which llm service to use if --use_llm is passed. This defaults to marker.services.gemini.GoogleGeminiService.
--help: see all of the flags that can be passed into marker. (it supports many more options then are listed above)

The list of supported languages for surya OCR is here. If you don’t need OCR, marker can work with any language.

Convert multiple files

`1`	`marker /path/to/input/folder`

marker supports all the same options from marker_single above.
--workers is the number of conversion workers to run simultaneously. This is automatically set by default, but you can increase it to increase throughput, at the cost of more CPU/GPU usage. Marker will use 5GB of VRAM per worker at the peak, and 3.5GB average.

Convert multiple files on multiple GPUs

`1`	`NUM_DEVICES=4 NUM_WORKERS=15 marker_chunk_convert ../pdf_in ../md_out`

NUM_DEVICES is the number of GPUs to use. Should be 2 or greater.
NUM_WORKERS is the number of parallel processes to run on each GPU.

Use from python

See the PdfConverter class at marker/converters/pdf.py function for additional arguments that can be passed.

from marker.converters.pdf import PdfConverter
from marker.models import create_model_dict
from marker.output import text_from_rendered

converter = PdfConverter(
    artifact_dict=create_model_dict(),
)
rendered = converter("FILEPATH")
text, _, images = text_from_rendered(rendered)

rendered will be a pydantic basemodel with different properties depending on the output type requested. With markdown output (default), you’ll have the properties markdown, metadata, and images. For json output, you’ll have children, block_type, and metadata.

Custom configuration

You can pass configuration using the ConfigParser. To see all available options, do marker_single --help.

from marker.converters.pdf import PdfConverter
from marker.models import create_model_dict
from marker.config.parser import ConfigParser

config = {
    "output_format": "json",
    "ADDITIONAL_KEY": "VALUE"
}
config_parser = ConfigParser(config)

converter = PdfConverter(
    config=config_parser.generate_config_dict(),
    artifact_dict=create_model_dict(),
    processor_list=config_parser.get_processors(),
    renderer=config_parser.get_renderer(),
    llm_service=config_parser.get_llm_service()
)
rendered = converter("FILEPATH")

Extract blocks

Each document consists of one or more pages. Pages contain blocks, which can themselves contain other blocks. It’s possible to programmatically manipulate these blocks.

Here’s an example of extracting all forms from a document:

from marker.converters.pdf import PdfConverter
from marker.models import create_model_dict
from marker.schema import BlockTypes

converter = PdfConverter(
    artifact_dict=create_model_dict(),
)
document = converter.build_document("FILEPATH")
forms = document.contained_blocks((BlockTypes.Form,))

Look at the processors for more examples of extracting and manipulating blocks.

Other converters

You can also use other converters that define different conversion pipelines:

Extract tables

The TableConverter will only convert and extract tables:

from marker.converters.table import TableConverter
from marker.models import create_model_dict
from marker.output import text_from_rendered

converter = TableConverter(
    artifact_dict=create_model_dict(),
)
rendered = converter("FILEPATH")
text, _, images = text_from_rendered(rendered)

This takes all the same configuration as the PdfConverter. You can specify the configuration force_layout_block=Table to avoid layout detection and instead assume every page is a table. Set output_format=json to also get cell bounding boxes.

You can also run this via the CLI with

`1`	`marker_single FILENAME --use_llm --force_layout_block Table --converter_cls marker.converters.table.TableConverter --output_format json`

OCR Only

If you only want to run OCR, you can also do that through the OCRConverter. Set --keep_chars to keep individual characters and bounding boxes.

from marker.converters.ocr import OCRConverter
from marker.models import create_model_dict

converter = OCRConverter(
    artifact_dict=create_model_dict(),
)
rendered = converter("FILEPATH")

This takes all the same configuration as the PdfConverter.

You can also run this via the CLI with

`1`	`marker_single FILENAME --converter_cls marker.converters.ocr.OCRConverter`

Structured Extraction (beta)

You can run structured extraction via the ExtractionConverter. This requires an llm service to be setup first (see here for details). You’ll get a JSON output with the extracted values.

from marker.converters.extraction import ExtractionConverter
from marker.models import create_model_dict
from marker.config.parser import ConfigParser
from pydantic import BaseModel

class Links(BaseModel):
    links: list[str]
    
schema = Links.model_json_schema()
config_parser = ConfigParser({
    "page_schema": schema
})

converter = ExtractionConverter(
    artifact_dict=create_model_dict(),
    config=config_parser.generate_config_dict(),
    llm_service=config_parser.get_llm_service(),
)
rendered = converter("FILEPATH")

Rendered will have an original_markdown field. If you pass this back in next time you run the converter, as the existing_markdown config key, you can skip re-parsing the document.

Output Formats

Markdown

Markdown output will include:

image links (images will be saved in the same folder)
formatted tables
embedded LaTeX equations (fenced with $$)
Code is fenced with triple backticks
Superscripts for footnotes

HTML

HTML output is similar to markdown output:

Images are included via img tags
equations are fenced with <math> tags
code is in pre tags

JSON

JSON output will be organized in a tree-like structure, with the leaf nodes being blocks. Examples of leaf nodes are a single list item, a paragraph of text, or an image.

The output will be a list, with each list item representing a page. Each page is considered a block in the internal marker schema. There are different types of blocks to represent different elements.

Pages have the keys:

id - unique id for the block.
block_type - the type of block. The possible block types can be seen in marker/schema/__init__.py. As of this writing, they are [“Line”, “Span”, “FigureGroup”, “TableGroup”, “ListGroup”, “PictureGroup”, “Page”, “Caption”, “Code”, “Figure”, “Footnote”, “Form”, “Equation”, “Handwriting”, “TextInlineMath”, “ListItem”, “PageFooter”, “PageHeader”, “Picture”, “SectionHeader”, “Table”, “Text”, “TableOfContents”, “Document”]
html - the HTML for the page. Note that this will have recursive references to children. The content-ref tags must be replaced with the child content if you want the full html. You can see an example of this at marker/output.py:json_to_html. That function will take in a single block from the json output, and turn it into HTML.
polygon - the 4-corner polygon of the page, in (x1,y1), (x2,y2), (x3, y3), (x4, y4) format. (x1,y1) is the top left, and coordinates go clockwise.
children - the child blocks.

The child blocks have two additional keys:

section_hierarchy - indicates the sections that the block is part of. 1 indicates an h1 tag, 2 an h2, and so on.
images - base64 encoded images. The key will be the block id, and the data will be the encoded image.

Note that child blocks of pages can have their own children as well (a tree structure).

{
      "id": "/page/10/Page/366",
      "block_type": "Page",
      "html": "<content-ref src='/page/10/SectionHeader/0'></content-ref><content-ref src='/page/10/SectionHeader/1'></content-ref><content-ref src='/page/10/Text/2'></content-ref><content-ref src='/page/10/Text/3'></content-ref><content-ref src='/page/10/Figure/4'></content-ref><content-ref src='/page/10/SectionHeader/5'></content-ref><content-ref src='/page/10/SectionHeader/6'></content-ref><content-ref src='/page/10/TextInlineMath/7'></content-ref><content-ref src='/page/10/TextInlineMath/8'></content-ref><content-ref src='/page/10/Table/9'></content-ref><content-ref src='/page/10/SectionHeader/10'></content-ref><content-ref src='/page/10/Text/11'></content-ref>",
      "polygon": [[0.0, 0.0], [612.0, 0.0], [612.0, 792.0], [0.0, 792.0]],
      "children": [
        {
          "id": "/page/10/SectionHeader/0",
          "block_type": "SectionHeader",
          "html": "<h1>Supplementary Material for <i>Subspace Adversarial Training</i> </h1>",
          "polygon": [
            [217.845703125, 80.630859375], [374.73046875, 80.630859375],
            [374.73046875, 107.0],
            [217.845703125, 107.0]
          ],
          "children": null,
          "section_hierarchy": {
            "1": "/page/10/SectionHeader/1"
          },
          "images": {}
        },
        ...
        ]
    }

Chunks

Chunks format is similar to JSON, but flattens everything into a single list instead of a tree. Only the top level blocks from each page show up. It also has the full HTML of each block inside, so you don’t need to crawl the tree to reconstruct it. This enable flexible and easy chunking for RAG.

Metadata

All output formats will return a metadata dictionary, with the following fields:

{
    "table_of_contents": [
      {
        "title": "Introduction",
        "heading_level": 1,
        "page_id": 0,
        "polygon": [...]
      }
    ], // computed PDF table of contents
    "page_stats": [
      {
        "page_id":  0, 
        "text_extraction_method": "pdftext",
        "block_counts": [("Span", 200), ...]
      },
      ...
    ]
}

LLM Services

When running with the --use_llm flag, you have a choice of services you can use:

Gemini - this will use the Gemini developer API by default. You’ll need to pass --gemini_api_key to configuration.
Google Vertex - this will use vertex, which can be more reliable. You’ll need to pass --vertex_project_id. To use it, set --llm_service=marker.services.vertex.GoogleVertexService.
Ollama - this will use local models. You can configure --ollama_base_url and --ollama_model. To use it, set --llm_service=marker.services.ollama.OllamaService.
Claude - this will use the anthropic API. You can configure --claude_api_key, and --claude_model_name. To use it, set --llm_service=marker.services.claude.ClaudeService.
OpenAI - this supports any openai-like endpoint. You can configure --openai_api_key, --openai_model, and --openai_base_url. To use it, set --llm_service=marker.services.openai.OpenAIService.
Azure OpenAI - this uses the Azure OpenAI service. You can configure --azure_endpoint, --azure_api_key, and --deployment_name. To use it, set --llm_service=marker.services.azure_openai.AzureOpenAIService.

These services may have additional optional configuration as well - you can see it by viewing the classes.

Internals

Marker is easy to extend. The core units of marker are:

Providers, at marker/providers. These provide information from a source file, like a PDF.
Builders, at marker/builders. These generate the initial document blocks and fill in text, using info from the providers.
Processors, at marker/processors. These process specific blocks, for example the table formatter is a processor.
Renderers, at marker/renderers. These use the blocks to render output.
Schema, at marker/schema. The classes for all the block types.
Converters, at marker/converters. They run the whole end to end pipeline.

To customize processing behavior, override the processors. To add new output formats, write a new renderer. For additional input formats, write a new provider.

Processors and renderers can be directly passed into the base PDFConverter, so you can specify your own custom processing easily.

API server

There is a very simple API server you can run like this:

1
2

pip install -U uvicorn fastapi python-multipart
marker_server --port 8001

This will start a fastapi server that you can access at localhost:8001. You can go to localhost:8001/docs to see the endpoint options.

You can send requests like this:

import requests
import json

post_data = {
    'filepath': 'FILEPATH',
    # Add other params here
}

requests.post("http://localhost:8001/marker", data=json.dumps(post_data)).json()

Note that this is not a very robust API, and is only intended for small-scale use. If you want to use this server, but want a more robust conversion option, you can use the hosted Datalab API.

Troubleshooting

There are some settings that you may find useful if things aren’t working the way you expect:

If you have issues with accuracy, try setting --use_llm to use an LLM to improve quality. You must set GOOGLE_API_KEY to a Gemini API key for this to work.
Make sure to set force_ocr if you see garbled text - this will re-OCR the document.
TORCH_DEVICE - set this to force marker to use a given torch device for inference.
If you’re getting out of memory errors, decrease worker count. You can also try splitting up long PDFs into multiple files.

Debugging

Pass the debug option to activate debug mode. This will save images of each page with detected layout and text, as well as output a json file with additional bounding box information.

Benchmarks

Overall PDF Conversion

We created a benchmark set by extracting single PDF pages from common crawl. We scored based on a heuristic that aligns text with ground truth text segments, and an LLM as a judge scoring method.

Method	Avg Time	Heuristic Score	LLM Score
marker	2.83837	95.6709	4.23916
llamaparse	23.348	84.2442	3.97619
mathpix	6.36223	86.4281	4.15626
docling	3.69949	86.7073	3.70429

Benchmarks were run on an H100 for markjer and docling - llamaparse and mathpix used their cloud services. We can also look at it by document type:

Document Type	Marker heuristic	Marker LLM	Llamaparse Heuristic	Llamaparse LLM	Mathpix Heuristic	Mathpix LLM	Docling Heuristic	Docling LLM
Scientific paper	96.6737	4.34899	87.1651	3.96421	91.2267	4.46861	92.135	3.72422
Book page	97.1846	4.16168	90.9532	4.07186	93.8886	4.35329	90.0556	3.64671
Other	95.1632	4.25076	81.1385	4.01835	79.6231	4.00306	83.8223	3.76147
Form	88.0147	3.84663	66.3081	3.68712	64.7512	3.33129	68.3857	3.40491
Presentation	95.1562	4.13669	81.2261	4	83.6737	3.95683	84.8405	3.86331
Financial document	95.3697	4.39106	82.5812	4.16111	81.3115	4.05556	86.3882	3.8
Letter	98.4021	4.5	93.4477	4.28125	96.0383	4.45312	92.0952	4.09375
Engineering document	93.9244	4.04412	77.4854	3.72059	80.3319	3.88235	79.6807	3.42647
Legal document	96.689	4.27759	86.9769	3.87584	91.601	4.20805	87.8383	3.65552
Newspaper page	98.8733	4.25806	84.7492	3.90323	96.9963	4.45161	92.6496	3.51613
Magazine page	98.2145	4.38776	87.2902	3.97959	93.5934	4.16327	93.0892	4.02041

Throughput

We benchmarked throughput using a single long PDF.

Method	Time per page	Time per document	VRAM used
marker	0.18	43.42	3.17GB

The projected throughput is 122 pages per second on an H100 - we can run 22 individual processes given the VRAM used.

Table Conversion

Marker can extract tables from PDFs using marker.converters.table.TableConverter. The table extraction performance is measured by comparing the extracted HTML representation of tables against the original HTML representations using the test split of FinTabNet. The HTML representations are compared using a tree edit distance based metric to judge both structure and content. Marker detects and identifies the structure of all tables in a PDF page and achieves these scores:

Method	Avg score	Total tables
marker	0.816	99
marker w/use_llm	0.907	99
gemini	0.829	99

The --use_llm flag can significantly improve table recognition performance, as you can see.

We filter out tables that we cannot align with the ground truth, since fintabnet and our layout model have slightly different detection methods (this results in some tables being split/merged).

Running your own benchmarks

You can benchmark the performance of marker on your machine. Install marker manually with:

1
2

git clone https://github.com/VikParuchuri/marker.git
poetry install

Overall PDF Conversion

Download the benchmark data here and unzip. Then run the overall benchmark like this:

`1`	`python benchmarks/overall.py --methods marker --scores heuristic,llm`

Options:

--use_llm use an llm to improve the marker results.
--max_rows how many rows to process for the benchmark.
--methods can be llamaparse, mathpix, docling, marker. Comma separated.
--scores which scoring functions to use, can be llm, heuristic. Comma separated.

Table Conversion

The processed FinTabNet dataset is hosted here and is automatically downloaded. Run the benchmark with:

`1`	`python benchmarks/table/table.py --max_rows 100`

Options:

--use_llm uses an llm with marker to improve accuracy.
--use_gemini also benchmarks gemini 2.0 flash.

How it works

Marker is a pipeline of deep learning models:

Extract text, OCR if necessary (heuristics, surya)
Detect page layout and find reading order (surya)
Clean and format each block (heuristics, texify, surya)
Optionally use an LLM to improve quality
Combine blocks and postprocess complete text

It only uses models where necessary, which improves speed and accuracy.

Limitations

PDF is a tricky format, so marker will not always work perfectly. Here are some known limitations that are on the roadmap to address:

Very complex layouts, with nested tables and forms, may not work
Forms may not be rendered well

Note: Passing the --use_llm and --force_ocr flags will mostly solve these issues.

note-gen

Mon, 09 Jun 2025 15:30:13 +0800

codexu/note-gen

NoteGen

English | 简体中文 | 日本語

Guide

NoteGen is a cross-platform Markdown note-taking application dedicated to using AI to bridge recording and writing, organizing fragmented knowledge into a readable note.

🖥️ Official Document: https://notegen.top

💬 Join WeChat/QQ Group

Why Choose NoteGen?

Lightweight: Installation package is only 20MB, free with no ads or bundled software.
Cross-platform: Supports Mac, Windows, Linux, and thanks to Tauri2’s cross-platform capabilities, will support iOS and Android in the future.
Supports multiple recording methods including screenshots, text, illustrations, files, links, etc., meeting fragmented recording needs across various scenarios.
Native Markdown(.md) as storage format, no modifications, easy to migrate.
Native offline usage, supporting real-time synchronization to GitHub, Gitee private repositories with history rollback, and WebDAV synchronization.
AI-enhanced: Configurable with ChatGPT, Gemini, Ollama, LM Studio, Grok, and other models, with support for custom third-party model configuration.
RAG: Your notes are your knowledge base. Support embedding models and reranking models.

Screenshots

https://github.com/user-attachments/assets/4f8a3bc5-17f5-4b36-9b17-d87128685257

Recording:

Writing:

Theme:

From Recording to Writing

Conventional note-taking applications typically don’t provide recording functionality. Users need to manually copy and paste content for recording, which greatly reduces efficiency. When faced with scattered recorded content, it requires significant effort to organize.

NoteGen is divided into Recording and Writing pages, with the following relationship:

Recordings can be organized into notes and transferred to the writing page for in-depth composition.
During writing, you can insert recordings at any time.

Recording

The recording function is similar to an AI chatbot, but when conversing with it, you can associate it with previously recorded content, switching from conversation mode to organization mode to arrange recordings into a readable note.

The following auxiliary features can help you record more effectively:

Tags to distinguish different recording scenarios.
Personas with support for custom prompts to precisely control your AI assistant.
Clipboard Assistant that automatically recognizes text or images in your clipboard and records them to your list.

Writing

The writing section is divided into two parts: File Manager and Markdown Editor.

File Manager

Supports management of local Markdown files and GitHub synchronized files.
Supports unlimited directory hierarchy.
Supports multiple sorting methods.

Markdown Editor

Supports WYSIWYG, instant rendering, and split-screen preview modes.
Supports version control with history rollback.
Supports AI assistance for conversation, continuation, polishing, and translation functions.
Supports image hosting, uploading images and converting them to Markdown image links.
Supports HTML to Markdown conversion, automatically converting copied browser content to Markdown format.
Supports outlines, math formulas, mind maps, charts, flowcharts, Gantt charts, sequence diagrams, staves, multimedia, voice reading, title anchors, code highlighting and copying, graphviz rendering, and plantuml UML diagrams.
Supports real-time local content saving, delayed (10s without editing) automatic synchronization, and history rollback.

Other Features

Global search for quickly finding and jumping to specific content.
Image hosting management for convenient management of image repository content.
Themes and appearance with support for dark themes and appearance settings for Markdown, code, etc.
Internationalization support, currently available in Chinese and English.

How to Use?

Download

Currently supports Mac, Windows, and Linux. Thanks to Tauri2’s cross-platform capabilities, it will support iOS and Android in the future.

Download NoteGen (alpha)

Enhancement

The note-taking application can be used directly without configuration. If you want a better experience, please open the settings page to configure AI and synchronization.

Contribute

Contributors

Star History

quarkdown

Fri, 06 Jun 2025 15:28:54 +0800

iamgio/quarkdown

Download
Latest | Stable

About

Quarkdown is a modern Markdown-based typesetting system, designed around the key concept of versatility, by seamlessly compiling a project into a print-ready book or an interactive presentation. All through an incredibly powerful Turing-complete extension of Markdown, ensuring your ideas flow automatically into paper.

Original credits: Attention Is All You Need

Born as an extension of CommonMark and GFM, the Quarkdown Flavor brings functions to Markdown, along with many other syntax extensions.

This is a function call:

1
2

.somefunction {arg1} {arg2}
    Body argument

Possibilities are unlimited thanks to an ever-expanding standard library, which offers layout builders, I/O, math, conditional statements and loops.

Not enough? You can still define your own functions and variables — all within Markdown. You can even create awesome libraries for everyone to use.

.function {greet}
    to from:
    **Hello, .to** from .from!

.greet {world} from:{iamgio}

Result: Hello, world from iamgio!

This out-of-the-box scripting support opens doors to complex and dynamic content that would be otherwise impossible to achieve with vanilla Markdown.

Combined with live preview and :zap: fast compilation speed, Quarkdown simply gets the work done.

Check the wiki to learn more about the language and its features.

Check out the demo presentation here

Built with Quarkdown itself — source code

(Desktop view is suggested)

As simple as you expect…

Inspired by: X-ray flashes from a nearby supermassive black hole accelerate mysteriously

...as complex as you need.

Targets

HTML
- :white_check_mark: Plain output (default)
- :white_check_mark: Slides ^{via reveal.js}
- :white_check_mark: Paged (books, articles) ^{via paged.js}
  Paged documents require a webserver to render in the browser. See the -p option below.
PDF
- :white_check_mark: All document types and features supported by HTML are also supported when exporting to PDF.
- Check the wiki’s PDF export page to learn more.

The desired document type can be set by calling the .doctype function within the source itself:

.doctype {slides}
.doctype {paged}

Comparison

	Quarkdown	Markdown	LaTeX	Typst	AsciiDoc	MDX
Concise and readable	:white_check_mark:	:white_check_mark:	:x:	:white_check_mark:	:white_check_mark:	:white_check_mark:
Full document control	:white_check_mark:	:x:	:white_check_mark:	:white_check_mark:	:x:	:x:
Scripting	:white_check_mark:	:x:	Partial	:white_check_mark:	:x:	:white_check_mark:
Book/article export	:white_check_mark:	:x:	:white_check_mark:	:white_check_mark:	:white_check_mark:	Third-party
Presentation export	:white_check_mark:	:x:	:white_check_mark:	:white_check_mark:	:white_check_mark:	Third-party
Learning curve	:green_circle:	:green_circle:	:red_circle:	:orange_circle:	:green_circle:	:green_circle:
Targets	HTML, PDF	HTML	PDF, PostScript	PDF	HTML, PDF, ePub	HTML

LaTeX Quarkdown

\tableofcontents

\section{Section}

\subsection{Subsection}

\begin{enumerate}
    \item \textbf{First} item
    \item \textbf{Second} item
\end{itemize}

\begin{center}
    This text is \textit{centered}.
\end{center}

\begin{figure}[!h]
    \centering
    \begin{subfigure}[b]
        \includegraphics[width=0.3\linewidth]{img1.png}
    \end{subfigure}
    \begin{subfigure}[b]
        \includegraphics[width=0.3\linewidth]{img2.png}
    \end{subfigure}
    \begin{subfigure}[b]
        \includegraphics[width=0.3\linewidth]{img3.png}
    \end{subfigure}
\end{figure}

.tableofcontents

# Section

## Subsection

1. **First** item
2. **Second** item

.center
    This text is _centered_.

.row alignment:{spacebetween}
    ![Image 1](img1.png)

    ![Image 2](img2.png)
    
    ![Image 3](img3.png)

Getting started

Installation

Download quarkdown.zip from the latest stable release or build it with gradlew distZip, and unzip it.

The bin directory contains the executable scripts. Optionally, adding it to your PATH allows you to access Quarkdown more easily.
The lib/qmd directory contains .qmd libraries that can be imported into a project.

Java 17 or higher is required. All major operating systems are supported.

Creating a project

Running quarkdown create [directory] will launch the prompt-based project wizard, making it quicker than ever to set up a new Quarkdown project, with all metadata and initial content already present.

For more information about the project creator, check out its wiki page.

Alternatively, you may manually create a .qmd source file and start from there.

Compiling

Running quarkdown c file.qmd will compile the given file and save the output to file.

If the project is composed by multiple source files, the target file must be the root one, i.e. the one that includes the other files.

How to include other files?

If you would like to familiarize yourself with Quarkdown instead, quarkdown repl lets you play with an interactive REPL mode.

Options

-p or --preview: enables automatic content reloading after compiling.
If a webserver is not running yet, it is started and the document is opened in the default browser.
This is required in order to render paged documents in the browser.
-w or --watch: recompiles the source everytime a file from the source directory is changed.

[!TIP] Combine -p -w to achieve live preview!

--pdf: produces a PDF file. Learn more in the wiki’s PDF export page.
-o <dir> or --output <dir>: sets the directory of the output files. Defaults to ./output.
-l <dir> or --libs <dir>: sets the directory where external libraries can be loaded from. Defaults to <install dir>/lib/qmd. (?)
-r <renderer> or --render <renderer>: sets the target renderer. Defaults to html. Accepted values:
- html
- html-pdf (equivalent to -r html --pdf)
--server-port <port>: optional customization of the local webserver’s port. Defaults to 8089.
--pretty: produces pretty output code. This is useful for debugging or to read the output code more easily, but it should be disabled in production as the results might be visually affected.
--clean: deletes the content of the output directory before producing new files. Destructive operation.
--strict: forces the program to exit if an error occurs. When not in strict mode, errors are shown as boxes in the document.
--no-media-storage: turns the media storage system off. (?)
-Dloglevel=<level> (JVM property): sets the log level. If set to warning or higher, the output content is not printed out.

Mock document

Mock, written in Quarkdown, is a comprehensive collection of visual elements offered by the language, making it ideal for exploring and understanding its key features — all while playing and experimenting hands-on with a concrete outcome in the form of pages or slides.

The document’s source files are available in the mock directory, and can be compiled via quarkdown c mock/main.qmd -p.
The PDF artifacts generated for all possible theme combinations are available and can be viewed in the generated branch.

Contributing

Contributions are welcome! Please check CONTRIBUTING.md to know how contribute via issues or pull requests.

Concept

The logo resembles the original Markdown icon, with focus on Quarkdown’s completeness, richness of features and customization options, emphasized by the revolving arrow all around the sphere.

What could be mistaken for a planet is actually a quark or, more specifically, a down quark, an elementary particle that is a major constituent of matter: they give life to every complex structure we know of, while also being one of the lightest objects in existence.

This is, indeed, the concept Quarkdown is built upon.

planka

Wed, 04 Jun 2025 15:30:26 +0800

plankanban/planka

PLANKA

Project mastering driven by fun

Client demo (without server features).

⚠️ The demo GIF and client demo are based on v1 and will be updated soon.

Key Features

Collaborative Kanban Boards: Create projects, boards, lists, cards, and manage tasks with an intuitive drag-and-drop interface
Real-Time Updates: Instant syncing across all users, no refresh needed
Rich Markdown Support: Write beautifully formatted card descriptions with a powerful markdown editor
Flexible Notifications: Get alerts through 100+ providers, fully customizable to your workflow
Seamless Authentication: Single sign-on with OpenID Connect integration
Multilingual & Easy to Translate: Full internationalization support for a global audience

How to Deploy

PLANKA is easy to install using multiple methods - learn more in the installation guide.

For configuration and environment settings, see the configuration section.

Contact

Interested in a hosted version of PLANKA? Email us at github@planka.group.

For any security issues, please do not create a public issue on GitHub - instead, report it privately by emailing security@planka.group.

Note: We do NOT offer any public support via email, please use GitHub.

Join our community: Get help, share ideas, or contribute on our Discord server.

License

PLANKA is fair-code distributed under the Fair Use License and PLANKA Pro/Enterprise License.

Source Available: The source code is always visible
Self-Hostable: Deploy and host it anywhere
Extensible: Customize with your own functionality
Enterprise Licenses: Available for additional features and support

For more details, check the License Guide.

Contributing

Found a bug or have a feature request? Check out our Contributing Guide to get started.

For setting up the project locally, see the development section.

Thanks to all our contributors!

english-note

Fri, 02 May 2025 15:29:49 +0800

hzpt-inet-club/english-note

英语语法笔记

背景

这个项目由 xiaoxunyao 提出，并且大量文本编辑的工作由他负责查阅资料和整理资料完成。在这个社会学会英语对于每位程序员的帮助都是有重大意义的，所以 INet 社区开始着手编写语法笔记，争取将复杂困难的语法知识点掰碎了告诉大家。

很多人对于英语都是不屑的，因为对于大部分的同学而言短期内不会考虑出国的问题，所以在社区内的不少同学英语都是较为薄弱的地方，这边可以参考知乎上的一则提问英语是否会成为开发工程师的发展瓶颈？中 Evan You 的回答。

不仅英语差会成为瓶颈，英语好还能成为优势，因为学习效率会比别人高。像我这样半路出家自学的人，只能靠英语了… –尤雨溪

学习的方法很多大神都贡献了很多方法和方式，我们参考了 Evan You 的方法，具体参考知乎上的一则提问上了大学还是完全不懂语法只想靠美剧或者英语书籍来的语感强行记忆，这种做法靠谱吗？，方法如下

语法也不是完全不需要。或者说，你需要做到的是借助语法去理解你看不懂的句子，而不是去记忆语法本身。理解的过程就是培养语感的过程。从这个角度来说，一些基础的语法知识，比如时态、从句啥的，是培养语感的前提条件。但是，我的看法是语法过了初学者的坎之后就不再是需要刻意去研究的东西，非英语专业尤其如此。

我自己就是语感党，以前考试从来都靠语感，从来不会去记忆具体的语法规则。至于效果… 我高二托福考了673（当时满分677），上海高考 146/150，还拿了个英语比赛的一等奖，高考可以加20分的那种。高中毕业后直接来美国读本科（参加高考是为了防止签证签不出），读硕士，工作，除了本科时候 Liberal Arts 的恐怖阅读量有点累，其他时候英语上从来没有什么障碍。

但是联系到题主的问题，语感的培养绝对不能只靠被动的接收，必须要靠主动的使用。只看书看剧带来的提高是非常有限的，语感只有在使用中才能提高。所以，除了看和听，还要写和说。写嘛，现在网络这么发达，多逛逛外国网站跟人交流或者辩论都可以，但务必保证发言要言之有物。之所以辩论会很有效是因为你需要很努力地思考组织语言去论证自己的正确性。说的方面，在缺少口语交流环境的情况下，背是一个机械但有效的方法。以我自己来说，实质性提高英语的主要手段是靠背新概念 + 背词汇…

所以说到底还是没有什么捷径可走的，想提高英语总得有所付出。 –尤雨溪

这边完成了第一步，语法的练习，后续的方法可以采用百词斩和新概念英语作为教材进行学习。

安装

直接使用「推荐」

点击链接打开网页直接可以阅读和学习。

本地使用

下载到本地

`1`	`git clone https://github.com/hzpt-inet-club/english-note.git`

`1`	`yarn init`

运行

`1`	`yarn docs:dev`

使用说明

本项目使用 VuePress 进行文档编写，并且使用 GitHub Actions 全自动的部署在 GitHub Page 上。

所有的内容在 docs 文件夹内，全部内容都采用了 MarkDown 的形式进行编写。

维护者

@hzpt-inet

@xiaoxunyao

如何贡献

在 INet 社区中拥有一个 home 项目，详细的说明了如何进行贡献项目，简单来说提出一个issue和提出一个pull Request 都是可以的。

贡献

内容贡献

感谢!

百词斩提供内容贡献

VuePress 提供项目贡献

人员贡献

感谢以下参与项目的人：