Aqua

MoeFlux：给国内开发者准备的模型 API 中转网关

Tue, 16 Jun 2026 00:00:00 GMT

如果你经常在国内环境里使用大模型 API，应该对这几个问题并不陌生：线路不稳定、调用延迟波动、客户端配置麻烦、不同工具之间反复切换 Key。这类问题不一定来自模型本身，更多时候是接入链路不够稳定。

MoeFlux 做的事情很直接：它把自己定位成一个面向国内开发者的模型 API 网关，提供更稳定、更低干扰、尽量保持原生兼容的模型中转服务。

它主要解决什么问题？

MoeFlux 首页的核心表达是“无界算力，满血直连”。从页面信息来看，它更强调下面几件事：

多地区节点协同承接：把请求分配到更合适的区域线路，减少单点波动带来的影响。
BGP / 专线优化：重点不是只看一次请求的延迟数字，而是更关注长期调用时的稳定性、绕路和抖动控制。
原生兼容现有工作流：尽量保持主流 OpenAI SDK、Codex CLI、常见客户端的接入方式，不需要为了换网关大改代码。
隐私边界更克制：服务本身主打“低干扰”，减少不必要的调用链路暴露和额外处理。

换句话说，它不是一个花哨的聊天网页，而是更偏开发者基础设施：你仍然使用原来的客户端、CLI 或 SDK，只是把请求入口切到 MoeFlux。

对 Codex 用户尤其友好

我看了一下它的说明文档，MoeFlux 对 Codex CLI 给出了比较完整的接入方式。核心配置是把 Codex 的模型供应商指向它的 API 地址：

model_provider = "cch"
model = "gpt-5.4"
disable_response_storage = true
approval_policy = "never"
sandbox_mode = "workspace-write"
web_search = "live"

[model_providers.cch]
name = "cch"
base_url = "https://api.moeflux.com/v1"
wire_api = "responses"
requires_openai_auth = true

这意味着你不需要换掉 Codex 的使用习惯：终端里照常跑 codex，VS Code 插件里也照常选择 API Key 登录，只需要把配置文件里的 provider 和 base_url 改好即可。

对于经常让 Codex 帮忙改项目、查 bug、跑构建、写文档的人来说，这种兼容性很关键。因为真正影响效率的不是“能不能调一次模型”，而是连续工作几个小时之后，链路是否还稳定、上下文是否能顺畅跑完、工具调用是否会频繁中断。

套餐选择比较细

MoeFlux 的套餐页目前能看到 Codex 订阅、Claude 订阅、Grok 等分类，其中 Codex 订阅提供了从试用到高额度的多个梯度。

比如页面上展示的 Codex 相关套餐包括：

试用临时套餐：7 天，适合先验证链路和体验。
Codex Mini / Lite：偏轻量使用，适合偶尔开发或研究。
Codex Lite Pro / SE / SE Max：更适合日常开发。
Codex Plus / Plus Max / Super：面向更高频、更大额度的专业使用。

页面还显示了每日限额、每周限额和并发数量。这个设计对开发者比较实用，因为你可以按自己的调用强度选套餐，而不是一上来就买很重的配置。

适合哪些人？

我觉得 MoeFlux 比较适合这几类用户：

国内环境下高频使用 Codex CLI 的开发者：尤其是需要长时间让 Codex 读项目、改代码、跑测试的人。
希望保留原生 SDK 使用方式的人：不想为了接入一个服务改掉现有 OpenAI SDK 或客户端结构。
对稳定性比花哨功能更敏感的人：比如写代码、批处理、文档生成、自动化任务，这类场景更怕中途断链。
想先小额度试用的人：套餐里有短周期试用和多个轻量档位，验证成本比较低。

怎么开始？

最简单的路径是：

打开 MoeFlux。
到“套餐订阅”里选择适合自己的套餐。
在“说明文档”里按自己的系统选择 macOS、Windows 或 Linux。
安装 Node.js 和 Codex CLI。
把 ~/.codex/config.toml 里的 base_url 配成 https://api.moeflux.com/v1。
使用 API Key 登录 Codex，然后照常使用。

如果你只是想确认它是否适合自己，可以先从短周期试用或轻量套餐开始。真正跑几次项目级任务，比单纯看介绍更能判断链路质量。

总结

MoeFlux 的卖点并不是重新发明一个 AI 客户端，而是把模型接入链路做成更适合国内开发者长期使用的形态：多节点、专线优化、原生兼容、套餐清晰，并且对 Codex 这类开发工具做了明确支持。

如果你已经把 AI 当成日常开发工作流的一部分，而不是偶尔问几句话的玩具，那么稳定的 API 网关本身就是生产力基础设施。MoeFlux 值得放进你的备选方案里试一试。

React + shadcn/ui + Zustand 技术栈展示

Sat, 13 Jun 2026 00:00:00 GMT

import TechShowcase from '../../../components/react/TechShowcase.tsx'

🚀 技术栈介绍

本文展示了如何在 Astro (Fuwari) 博客中成功集成以下现代前端技术栈：

技术	版本	用途
React	19.x	UI 组件框架
Tailwind CSS	3.x	实用优先的 CSS 框架
shadcn/ui	latest	基于 Radix UI 的组件库
Zustand	5.x	轻量级状态管理
Astro MDX	4.x	在 Markdown 中使用 JSX 组件

✨ 实时组件演示

下面的所有组件都是 真实可交互 的 React 组件，通过 MDX 直接嵌入到这篇博客帖子中：

🏗️ 技术架构

MDX 集成

这篇文章本身就是一个 .mdx 文件，它允许我们在 Markdown 中直接导入和使用 React 组件：

// 在 MDX 中导入 React 组件
import TechShowcase from '../../../components/react/TechShowcase.tsx'

// 使用 client:load 指令使其在客户端可交互
<TechShowcase client:only="react" />

Zustand Store 示例

// src/stores/taskStore.ts
import { create } from 'zustand'

const useTaskStore = create((set, get) => ({
  tasks: [],
  addTask: (title, priority) =>
    set((state) => ({
      tasks: [...state.tasks, { id: Date.now(), title, priority, completed: false }],
    })),
  toggleTask: (id) =>
    set((state) => ({
      tasks: state.tasks.map((t) => t.id === id ? { ...t, completed: !t.completed } : t),
    })),
  getStats: () => {
    const { tasks } = get()
    return {
      total: tasks.length,
      completed: tasks.filter((t) => t.completed).length,
    }
  },
}))

shadcn/ui 组件使用

import { Button } from '@/components/ui/button'
import { Card, CardContent, CardHeader, CardTitle } from '@/components/ui/card'
import { Badge } from '@/components/ui/badge'
import { Tabs, TabsContent, TabsList, TabsTrigger } from '@/components/ui/tabs'

// 按钮变体
<Button variant="default" client:load>Default</Button>
<Button variant="destructive" client:load>Destructive</Button>
<Button variant="outline" client:load>Outline</Button>
<Button variant="ghost" client:load>Ghost</Button>

📦 引入的依赖

本次集成新增了以下依赖包：

@astrojs/react — Astro 的 React 集成
@astrojs/mdx — Astro 的 MDX 支持
react + react-dom — React 核心库
zustand — 状态管理
class-variance-authority — 组件变体管理 (CVA)
clsx + tailwind-merge — 类名工具函数
lucide-react — 图标库
@radix-ui/* — 无障碍 UI 原语

[!TIP] shadcn/ui 的组件代码直接存在于项目中 (src/components/ui/)，你可以自由定制样式和行为，无需等待上游更新。

🎯 总结

通过这次集成，我们的 Astro 博客现在具备了：

✅ React 组件支持 — 可以在 Astro 页面和 MDX 文章中使用 React
✅ MDX 写作 — 可以在 Markdown 中嵌入可交互的 React 组件
✅ shadcn/ui 组件库 — Button、Card、Badge、Tabs、Switch、Progress、Accordion 等
✅ Zustand 状态管理 — 轻量级全局状态，无需 Provider
✅ Tailwind CSS 增强 — 配合 shadcn/ui 的设计 Token 系统

Rust实现简单链表

Sat, 13 Jun 2026 00:00:00 GMT

use std::cell::RefCell;
use std::rc::Rc;
type NodeRef<T> = Rc<RefCell<Node<T>>>;
#[derive(Clone)]
struct Node<T: Clone> {
    data: Option<T>,
    next: Option<NodeRef<T>>,
    previous: Option<NodeRef<T>>,
}
struct LinkedList<T: Clone> {
    head: Option<NodeRef<T>>,
    tail: Option<NodeRef<T>>,
    pub size: usize,
}
impl<T: Clone> LinkedList<T> {
    fn get_ptr_at(&self, index: usize) -> NodeRef<T> {
        if index < (self.size / 2) as usize {
            let head = self.head.clone().unwrap().clone();
            let mut ptr = head;
            for i in 0..index+1 {
                let next = ptr.borrow().next.clone().unwrap();
                ptr = next;
            }
            ptr
        } else {
            let tail = self.tail.clone().unwrap().clone();
            let mut ptr = tail;
            for i in 0..self.size - index {
                let prev = ptr.borrow().previous.clone().unwrap();
                ptr = prev;
            }
            ptr
        }
    }
    pub fn is_empty(&self) -> bool {
        self.head
            .clone()
            .unwrap()
            .borrow()
            .next
            .clone()
            .unwrap()
            .borrow()
            .next
            .is_none()
            && self
                .tail
                .clone()
                .unwrap()
                .borrow()
                .previous
                .clone()
                .unwrap()
                .borrow()
                .previous
                .is_none()
    }
    fn insert_first(&mut self, value: T) {
        let new_node = Rc::new(RefCell::new(Node {
            data: Some(value),
            next: None,
            previous: None,
        }));
        let new_head = self.head.clone().unwrap();
        let new_tail = self.tail.clone().unwrap();
        new_head.borrow_mut().next = Some(Rc::clone(&new_node));
        new_node.borrow_mut().previous = Some(Rc::clone(&new_head));
        new_tail.borrow_mut().previous = Some(Rc::clone(&new_node));
        new_node.borrow_mut().next = Some(Rc::clone(&new_tail));
        self.tail = Some(new_tail);
        self.head = Some(new_head);
    }
    pub fn new() -> Self {
        let head = Rc::new(RefCell::new(Node {
            data: None,
            next: None,
            previous: None,
        }));

        let tail = Rc::new(RefCell::new(Node {
            data: None,
            next: None,
            previous: Some(Rc::clone(&head)),
        }));

        head.borrow_mut().next = Some(Rc::clone(&tail));

        Self {
            head: Some(head),
            tail: Some(tail),
            size: 0,
        }
    }

    pub fn push_back(&mut self, value: T) {
        if !self.is_empty() {
            let new_node = Rc::new(RefCell::new(Node {
                data: Some(value),
                next: None,
                previous: None,
            }));
            let tail = &self.tail.clone().unwrap();
            let mut new_tail = tail.clone();
            let prev = new_tail.borrow().previous.clone().unwrap();
            prev.borrow_mut().next = Some(Rc::clone(&new_node));
            new_node.borrow_mut().previous = Some(prev);
            new_node.borrow_mut().next = Some(new_tail.clone());
            new_tail.borrow_mut().previous = Some(Rc::clone(&new_node));
            self.tail = Some(new_tail);
        } else {
            self.insert_first(value);
        }
        self.size += 1;
    }
    pub fn push_front(&mut self, value: T) {
        if !self.is_empty() {
            let new_node = Rc::new(RefCell::new(Node {
                data: Some(value),
                next: None,
                previous: None,
            }));
            let head = &self.head.clone().unwrap();
            let mut new_head = head.clone();
            let next = new_head.borrow().next.clone().unwrap();
            next.borrow_mut().next = Some(Rc::clone(&new_node));
            new_head.borrow_mut().next = Some(Rc::clone(&new_node));
            new_node.borrow_mut().next = Some(next);
            new_node.borrow_mut().previous = Some(new_head.clone());
            self.head = Some(new_head);
        } else {
            self.insert_first(value);
        }
        self.size += 1;
    }
    pub fn get(&self, index: usize) -> Result<Option<T>, String> {
        return if index >= self.size as usize || index < 0 {
            Err("".to_string())
        } else {
            let ptr = self.get_ptr_at(index);
            let value = ptr.borrow().clone().data;
            Ok(value)
        };
    }
    pub fn insert_at(&mut self,value:T,index:usize)->Result<(),String>{
        if self.size==0{
            self.push_back(value);
            return Ok(())
        }
        if self.size == index{
            self.push_back(value);
            return Ok(())
        }
        if self.size == 0{
            self.push_front(value);
            return Ok(())
        }
        let ptr=self.get_ptr_at(index);
        let new_previous=ptr.borrow().previous.clone().unwrap();
        let new_node=Rc::new(RefCell::new(Node{
            data: Some(value),
            next: Some(ptr.clone()),
            previous: Some(new_previous.clone()),
        }));
        ptr.borrow_mut().previous=Some(Rc::clone(&new_node));
        new_previous.borrow_mut().next=Some(Rc::clone(&new_node));
        self.size+=1;
        Ok(())
    }
    pub fn remove_at(&mut self, index: usize) -> Result<Option<T>, String> {
        return if index >= self.size as usize || index < 0 {
            Err("".to_string())
        } else {
            let ptr = self.get_ptr_at(index);
            let new_previous = ptr.borrow().clone().previous.unwrap();
            let new_next = ptr.borrow().clone().next.unwrap();
            new_previous.borrow_mut().next = Some(new_next.clone());
            new_next.borrow_mut().previous = Some(new_previous.clone());
            ptr.borrow().previous.clone().unwrap().borrow_mut().next = Some(new_next.clone());
            ptr.borrow().next.clone().unwrap().borrow_mut().previous = Some(new_previous.clone());
            let value = ptr.borrow().clone().data;
            self.size -= 1;
            Ok(value)
        };
    }
}
fn main() {
    let mut list_i32: LinkedList<i32> = LinkedList::new();
    for i in 0..100 {
        list_i32.push_back(i);
    }
    list_i32.insert_at(-1, 1).expect("TODO: panic message");
    list_i32.insert_at(-1, 0).expect("TODO: panic message");
    list_i32.insert_at(-1, list_i32.size-1).expect("TODO: panic message");
    list_i32.insert_at(-1, list_i32.size).expect("TODO: panic message");
    list_i32.insert_at(-1, 50).expect("TODO: panic message");
    for i in 0..list_i32.size{
        if let Ok(Some(v))= list_i32.get(i){
            println!("{}",v);
        }
    }
    return;
}

Markdown Extended Features

Wed, 01 May 2024 00:00:00 GMT

GitHub Repository Cards

You can add dynamic cards that link to GitHub repositories, on page load, the repository information is pulled from the GitHub API.

::github{repo="Fabrizz/MMM-OnSpotify"}

Create a GitHub repository card with the code ::github{repo="<owner>/<repo>"}.

::github{repo="saicaca/fuwari"}

Admonitions

Following types of admonitions are supported: note tip important warning caution

:::note Highlights information that users should take into account, even when skimming. :::

:::tip Optional information to help a user be more successful. :::

:::important Crucial information necessary for users to succeed. :::

:::warning Critical content demanding immediate user attention due to potential risks. :::

:::caution Negative potential consequences of an action. :::

Basic Syntax

:::note
Highlights information that users should take into account, even when skimming.
:::

:::tip
Optional information to help a user be more successful.
:::

Custom Titles

The title of the admonition can be customized.

:::note[MY CUSTOM TITLE] This is a note with a custom title. :::

:::note[MY CUSTOM TITLE]
This is a note with a custom title.
:::

GitHub Syntax

[!TIP] The GitHub syntax is also supported.

> [!NOTE]
> The GitHub syntax is also supported.

> [!TIP]
> The GitHub syntax is also supported.

Spoiler

You can add spoilers to your text. The text also supports Markdown syntax.

The content :spoiler[is hidden ayyy]!

The content :spoiler[is hidden **ayyy**]!

Expressive Code Example

Wed, 10 Apr 2024 00:00:00 GMT

Here, we'll explore how code blocks look using Expressive Code. The provided examples are based on the official documentation, which you can refer to for further details.

Expressive Code

Syntax Highlighting

Regular syntax highlighting

console.log('This code is syntax highlighted!')

Rendering ANSI escape sequences

ANSI colors:
- Regular: [31mRed[0m [32mGreen[0m [33mYellow[0m [34mBlue[0m [35mMagenta[0m [36mCyan[0m
- Bold:    [1;31mRed[0m [1;32mGreen[0m [1;33mYellow[0m [1;34mBlue[0m [1;35mMagenta[0m [1;36mCyan[0m
- Dimmed:  [2;31mRed[0m [2;32mGreen[0m [2;33mYellow[0m [2;34mBlue[0m [2;35mMagenta[0m [2;36mCyan[0m

256 colors (showing colors 160-177):
[38;5;160m160 [38;5;161m161 [38;5;162m162 [38;5;163m163 [38;5;164m164 [38;5;165m165[0m
[38;5;166m166 [38;5;167m167 [38;5;168m168 [38;5;169m169 [38;5;170m170 [38;5;171m171[0m
[38;5;172m172 [38;5;173m173 [38;5;174m174 [38;5;175m175 [38;5;176m176 [38;5;177m177[0m

Full RGB colors:
[38;2;34;139;34mForestGreen - RGB(34, 139, 34)[0m

Text formatting: [1mBold[0m [2mDimmed[0m [3mItalic[0m [4mUnderline[0m

Editor & Terminal Frames

Code editor frames

console.log('Title attribute example')

<!-- src/content/index.html -->
<div>File name comment example</div>

Terminal frames

echo "This terminal frame has no title"

Write-Output "This one has a title!"

Overriding frame types

echo "Look ma, no frame!"

# Without overriding, this would be a terminal frame
function Watch-Tail { Get-Content -Tail 20 -Wait $args }
New-Alias tail Watch-Tail

Text & Line Markers

Marking full lines & line ranges

// Line 1 - targeted by line number
// Line 2
// Line 3
// Line 4 - targeted by line number
// Line 5
// Line 6
// Line 7 - targeted by range "7-8"
// Line 8 - targeted by range "7-8"

Selecting line marker types (mark, ins, del)

function demo() {
  console.log('this line is marked as deleted')
  // This line and the next one are marked as inserted
  console.log('this is the second inserted line')

  return 'this line uses the neutral default marker type'
}

Adding labels to line markers

// labeled-line-markers.jsx
<button
  role="button"
  {...props}
  value={value}
  className={buttonClassName}
  disabled={disabled}
  active={active}
>
  {children &&
    !active &&
    (typeof children === 'string' ? <span>{children}</span> : children)}
</button>

Adding long labels on their own lines

// labeled-line-markers.jsx
<button
  role="button"
  {...props}

  value={value}
  className={buttonClassName}

  disabled={disabled}
  active={active}
>

  {children &&
    !active &&
    (typeof children === 'string' ? <span>{children}</span> : children)}
</button>

Using diff-like syntax

+this line will be marked as inserted
-this line will be marked as deleted
this is a regular line

--- a/README.md
+++ b/README.md
@@ -1,3 +1,4 @@
+this is an actual diff file
-all contents will remain unmodified
 no whitespace will be removed either

Combining syntax highlighting with diff-like syntax

  function thisIsJavaScript() {
    // This entire block gets highlighted as JavaScript,
    // and we can still add diff markers to it!
-   console.log('Old code to be removed')
+   console.log('New and shiny code!')
  }

Marking individual text inside lines

function demo() {
  // Mark any given text inside lines
  return 'Multiple matches of the given text are supported';
}

Regular expressions

console.log('The words yes and yep will be marked.')

Escaping forward slashes

echo "Test" > /home/test.txt

Selecting inline marker types (mark, ins, del)

function demo() {
  console.log('These are inserted and deleted marker types');
  // The return statement uses the default marker type
  return true;
}

Word Wrap

Configuring word wrap per block

// Example with wrap
function getLongString() {
  return 'This is a very long string that will most probably not fit into the available space unless the container is extremely wide'
}

// Example with wrap=false
function getLongString() {
  return 'This is a very long string that will most probably not fit into the available space unless the container is extremely wide'
}

Configuring indentation of wrapped lines

// Example with preserveIndent (enabled by default)
function getLongString() {
  return 'This is a very long string that will most probably not fit into the available space unless the container is extremely wide'
}

// Example with preserveIndent=false
function getLongString() {
  return 'This is a very long string that will most probably not fit into the available space unless the container is extremely wide'
}

Collapsible Sections

// All this boilerplate setup code will be collapsed
import { someBoilerplateEngine } from '@example/some-boilerplate'
import { evenMoreBoilerplate } from '@example/even-more-boilerplate'

const engine = someBoilerplateEngine(evenMoreBoilerplate())

// This part of the code will be visible by default
engine.doSomething(1, 2, 3, calcFn)

function calcFn() {
  // You can have multiple collapsed sections
  const a = 1
  const b = 2
  const c = a + b

  // This will remain visible
  console.log(`Calculation result: ${a} + ${b} = ${c}`)
  return c
}

// All this code until the end of the block will be collapsed again
engine.closeConnection()
engine.freeMemory()
engine.shutdown({ reason: 'End of example boilerplate code' })

Line Numbers

Displaying line numbers per block

// This code block will show line numbers
console.log('Greetings from line 2!')
console.log('I am on line 3')

// Line numbers are disabled for this block
console.log('Hello?')
console.log('Sorry, do you know what line I am on?')

Changing the starting line number

console.log('Greetings from line 5!')
console.log('I am on line 6')

Simple Guides for Fuwari

Mon, 01 Apr 2024 00:00:00 GMT

Cover image source: Source

This blog template is built with Astro. For the things that are not mentioned in this guide, you may find the answers in the Astro Docs.

Front-matter of Posts

---
title: My First Blog Post
published: 2023-09-09
description: This is the first post of my new Astro blog.
image: ./cover.jpg
tags: [Foo, Bar]
category: Front-end
draft: false
---

Attribute	Description
`title`	The title of the post.
`published`	The date the post was published.
`description`	A short description of the post. Displayed on index page.
`image`	The cover image path of the post.<br/>1. Start with `http://` or `https://`: Use web image<br/>2. Start with `/`: For image in `public` dir<br/>3. With none of the prefixes: Relative to the markdown file
`tags`	The tags of the post.
`category`	The category of the post.
`draft`	If this post is still a draft, which won't be displayed.

Where to Place the Post Files

Your post files should be placed in src/content/posts/ directory. You can also create sub-directories to better organize your posts and assets.

src/content/posts/
├── post-1.md
└── post-2/
    ├── cover.png
    └── index.md

Markdown Example

Sun, 01 Oct 2023 00:00:00 GMT

An h1 header

Paragraphs are separated by a blank line.

2nd paragraph. Italic, bold, and monospace. Itemized lists look like:

this one
that one
the other one

Note that --- not considering the asterisk --- the actual text content starts at 4-columns in.

Block quotes are written like so.

They can span multiple paragraphs, if you like.

Use 3 dashes for an em-dash. Use 2 dashes for ranges (ex., "it's all in chapters 12--14"). Three dots ... will be converted to an ellipsis. Unicode is supported. ☺

An h2 header

Here's a numbered list:

first item
second item
third item

Note again how the actual text starts at 4 columns in (4 characters from the left side). Here's a code sample:

# Let me re-iterate ...
for i in 1 .. 10 { do-something(i) }

As you probably guessed, indented 4 spaces. By the way, instead of indenting the block, you can use delimited blocks, if you like:

define foobar() {
    print "Welcome to flavor country!";
}

(which makes copying & pasting easier). You can optionally mark the delimited block for Pandoc to syntax highlight it:

import time
# Quick, count to ten!
for i in range(10):
    # (but not *too* quick)
    time.sleep(0.5)
    print i

An h3 header

Now a nested list:

First, get these ingredients:
- carrots
- celery
- lentils
Boil some water.

Dump everything in the pot and follow this algorithm:

 find wooden spoon
 uncover pot
 stir
 cover pot
 balance wooden spoon precariously on pot handle
 wait 10 minutes
 goto first step (or shut off burner when done)

Do not bump wooden spoon or it will fall.

Notice again how text always lines up on 4-space indents (including that last line which continues item 3 above).

Here's a link to a website, to a local doc, and to a section heading in the current doc. Here's a footnote [^1].

[^1]: Footnote text goes here.

Tables can look like this:

size material color

9 leather brown 10 hemp canvas natural 11 glass transparent

Table: Shoes, their sizes, and what they're made of

(The above is the caption for the table.) Pandoc also supports multi-line tables:

keyword text

red Sunsets, apples, and other red or reddish things.

green Leaves, grass, frogs and other things it's not easy being.

A horizontal rule follows.

Here's a definition list:

apples : Good for making applesauce. oranges : Citrus! tomatoes : There's no "e" in tomatoe.

Again, text is indented 4 spaces. (Put a blank line between each term/definition pair to spread things out more.)

Here's a "line block":

| Line one | Line too | Line tree

and images can be specified like so:

Inline math equations go in like so: $\omega = d\phi / dt$. Display math should get its own line and be put in in double-dollarsigns:

$$I = \int \rho R^{2} dV$$

$$ \begin{equation*} \pi =3.1415926535 ;8979323846;2643383279;5028841971;6939937510;5820974944 ;5923078164;0628620899;8628034825;3421170679;\ldots \end{equation*} $$

And note that you can backslash-escape any punctuation characters which you wish to be displayed literally, ex.: `foo`, *bar*, etc.

Include Video in the Posts

Tue, 01 Aug 2023 00:00:00 GMT

Just copy the embed code from YouTube or other platforms, and paste it in the markdown file.

---
title: Include Video in the Post
published: 2023-10-19
// ...
---

<iframe width="100%" height="468" src="https://www.youtube.com/embed/5gIf0_xpFPI?si=N1WTorLKL0uwLsU_" title="YouTube video player" frameborder="0" allowfullscreen></iframe>

YouTube

Bilibili