要/会/能/可以 — Modal Verbs Compared

Four verbs for four kinds of "can"

English overloads a single word for four very different ideas. "I can swim" could mean I learned how, or my leg isn't broken today, or the lifeguard said it's fine, or I'm about to jump in. Mandarin refuses that overload. It splits the modal space into four distinct verbs, and the listener expects you to pick the right one. Ambiguity is not a default here — it's a bug.

Think of it as four methods on a Modal interface with non-overlapping signatures. Before you speak, ask which branch applies: is this about skill (learned), capability (physical or circumstantial), permission (allowed), or volition (want / will / need)? The answer picks the verb. Misroute the call and you're still understandable — but you've leaked information about which field in the modal struct you thought you were setting.

// The four branches of Mandarin's "can".
interface Modal {
    skill(verb):        "会";   // learned ability
    capability(verb):   "能";   // physical / circumstantial
    permission(verb):   "可以"; // socially allowed
    volition(verb):     "要";   // want / will / need
}

1. The decision table

One question per verb. Run the question in your head; the answer is the modal.

2. 会 — learned skill (and future prediction)

会 is the modal for anything you had to study, practice, or otherwise acquire. Swimming, driving, cooking, speaking a language, playing an instrument — all 会. The test: could a child be born knowing this? If no, you want 会.

// 我 会 游泳。
// wǒ huì yóuyǒng
// "I can swim." (I learned how.)
I.skill(swim);

// 她 会 说 中文。
// tā huì shuō zhōngwén
// "She can speak Chinese."
she.skill(speak(chinese));

// 我 不 会 开车。
// wǒ bú huì kāichē
// "I can't drive." (Never learned.)
!I.skill(drive);

There is a second 会: future likelihood or prediction. 明天 会 下雨 (míngtiān huì xiàyǔ) = "It will rain tomorrow." This isn't a skill — it's the forecasting verb. Same character, different slot. Context disambiguates: a skill 会 takes a verb object; a prediction 会 frames a whole clause.

3. 能 — physical / circumstantial capability

能 is about whether the world lets you do the thing right now. Your body is up to it. Your schedule allows it. The road isn't closed. It's never about whether you learned — it's about whether the runtime can execute.

// 我 能 跑 十 公里。
// wǒ néng pǎo shí gōnglǐ
// "I can run 10 km." (Physical capacity.)
I.capability(run("10km"));

// 我 今天 能 来。
// wǒ jīntiān néng lái
// "I can come today." (Schedule permits.)
I.capability(come(today));

// 他 受伤 了，不 能 走路。
// tā shòushāng le, bù néng zǒulù
// "He's hurt; he can't walk." (Body can't.)
he.injured = true;
!he.capability(walk);

A subtle third use: tentative permission. 我 能 用 你 的 电脑 吗? = "Could I use your computer?" It's softer than 可以 — closer to "am I able" than "am I allowed." Many speakers treat 能 and 可以 as interchangeable for polite requests. They're not interchangeable anywhere else.

4. 可以 — permission & social OK

可以 is the authorization check. Is it allowed? Is it socially acceptable? Will the rule-enforcer (parent, sign, host, law) let this through? Think of it as hasPermission(action) — a boolean query against a permissions table, not against the laws of physics.

// 这里 可以 抽烟 吗？
// zhèlǐ kěyǐ chōuyān ma?
// "Can I smoke here?" (Is it allowed?)
here.permission(smoke) ?

// 你 可以 走 了。
// nǐ kěyǐ zǒu le
// "You can leave now." (Permission granted.)
you.permission(leave) = true;

// 我 可以 用 一下 吗？
// wǒ kěyǐ yòng yíxià ma?
// "May I use it for a moment?"
I.permission(useBriefly) ?

In practice 可以 almost never talks about physical capability. If the question is whether the universe permits something, reach for 能. If the question is whether a person or rule permits it, reach for 可以.

5. 要 — want, will, need

要 is the volitional modal. It bundles three meanings that share one root: the speaker (or subject) has an intention, a plan, or an obligation. English splits these into "want," "will," and "need"; Mandarin keeps them under one roof.

// 我 要 一 杯 咖啡。
// wǒ yào yì bēi kāfēi
// "I want a coffee." (Ordering.)
I.want(coffee);

// 我 要 去 北京。
// wǒ yào qù běijīng
// "I'm going to Beijing." (Near-future plan.)
I.intend(goTo(beijing));

// 你 要 小心。
// nǐ yào xiǎoxīn
// "You need to be careful." (Obligation.)
you.must(careful);

要 in a restaurant is blunt but normal — it's how you order. In other social contexts it can sound forceful; softer alternatives are 想 (would like) and 想要 (would like to have). Pick politeness by the situation, not by a universal rule.

6. Adjacent modals

A handful more live in this namespace. Once the big four are in place, these fit cleanly around them.

想 vs 要: almost the same idea, different force. 我 想 喝 茶 = "I'd like some tea." 我 要 喝 茶 = "I want tea" / "I'm going to drink tea." Same tea. Different register.

7. The "I can swim" flowchart

When English gives you "can," run the branches in this order. The first one that matches wins.

function translateCan(action, context) {
    if (context.hadToLearn)          return "会";
    if (context.physicalOrCircumstantial) return "能";
    if (context.aboutPermission)     return "可以";
    if (context.aboutIntent)         return "要"; // or 想
    throw new Error("ambiguous — ask again");
}

Applied to "I can swim": did I learn? Yes → 我 会 游泳. Applied to "I can swim today (the pool's open)": circumstances → 我 今天 能 游泳. Applied to "Can I swim here?": permission → 这里 可以 游泳 吗?

8. Negation

Each modal negates with 不 prepended. The meanings stay in their respective lanes.

9. Sample sentences

Twelve sentences across the four modals. Read the analogy column; the modal should feel forced — like an annotation, not a guess.

// 我 会 说 一点 中文。
// wǒ huì shuō yìdiǎn zhōngwén
// "I can speak a little Chinese." (skill)
I.skill(speak(chinese, "a little"));

// 他 会 弹 吉他。
// tā huì tán jítā
// "He can play guitar." (skill)
he.skill(play(guitar));

// 明天 会 下雨。
// míngtiān huì xiàyǔ
// "It will rain tomorrow." (prediction)
forecast(tomorrow).rain = true;

// 我 能 举起 这 个 箱子。
// wǒ néng jǔqǐ zhè ge xiāngzi
// "I can lift this box." (physical capability)
I.capability(lift(box));

// 他 今天 不 能 上班。
// tā jīntiān bù néng shàngbān
// "He can't come to work today." (circumstantial)
!he.capability(work(today));

// 你 可以 坐 这里。
// nǐ kěyǐ zuò zhèlǐ
// "You can sit here." (permission granted)
you.permission(sit(here)) = true;

// 这里 不 可以 拍照。
// zhèlǐ bù kěyǐ pāizhào
// "No photos here." (permission denied)
here.permission(photo) = false;

// 我 要 回家。
// wǒ yào huíjiā
// "I'm going home." / "I want to go home." (intent)
I.intend(goHome);

// 你 要 多 喝水。
// nǐ yào duō hē shuǐ
// "You need to drink more water." (advice / need)
you.must(drinkMore(water));

// 我 想 买 一 本 书。
// wǒ xiǎng mǎi yì běn shū
// "I'd like to buy a book." (softer want)
I.wouldLike(buy(book));

// 你 应该 休息 一下。
// nǐ yīnggāi xiūxi yíxià
// "You should rest a bit." (should)
you.should(rest);

// 我 必须 去 机场。
// wǒ bìxū qù jīchǎng
// "I must go to the airport." (hard requirement)
I.must(goTo(airport));

10. Common mistakes

11. Next steps

Modals combine heavily with question particles (to ask permission) and with the 把 construction (to frame deliberate actions). The next two articles wire those together.

• Question particles (吗 / 呢 / 吧) — turning modals into requests
• The 把 construction — methods on objects, intent made explicit
• Module 1: The Runtime — sentence execution and word order

Four verbs, four branches. Once the decision is automatic, half of everyday Mandarin becomes a lookup instead of a guess.