diff --git a/docs.json b/docs.json
index efe98fa1a..a264cc1e4 100644
--- a/docs.json
+++ b/docs.json
@@ -469,6 +469,7 @@
             "group": "Fift",
             "pages": [
               "languages/fift/overview",
+              "languages/fift/types",
               "languages/fift/fift-and-tvm-assembly",
               "languages/fift/deep-dive",
               "languages/fift/multisig",
diff --git a/languages/fift/types.mdx b/languages/fift/types.mdx
new file mode 100644
index 000000000..d015e9678
--- /dev/null
+++ b/languages/fift/types.mdx
@@ -0,0 +1,52 @@
+---
+title: "Types"
+sidebarTitle: "Types"
+noindex: "true"
+---
+
+import { Aside } from '/snippets/aside.jsx';
+
+The Fift stack can contain values of the following types:
+
+| Type           | Description                                                                                                                                                                                                                                             |
+| -------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `Integer`      | A TVM signed 257-bit integer.                                                                                                                                                                                                                           |
+| `Cell`         | A [TVM cell](/foundations/serialization/cells) for persistent data storage on TON Blockchain. A cell consists of up to `1023` data bits and up to `4` references to other cells.                                                                        |
+| `Slice`        | A TVM slice is a read-only view of a TVM cell that allows sequential access to the cell's data and references. A cell can be converted into a slice, extracting stored bits and references without modifying the original cell.                         |
+| `Builder`      | A TVM builder is used to construct a cell by adding data and cell references.                                                                                                                                                                           |
+| `Null`         | The TVM Null type has exactly one value `null`. In Fift, `null` is mostly used to initialize `Box`'es, hashmaps and lists. Usually denoted by `⊥`.                                                                                                      |
+| `Tuple`        | A tuple is an ordered collection of values of any of the Fift types in this list, where each value is not necessarily of the same type.                                                                                                                 |
+| `Continuation` | A [TVM continuation](/tvm/continuations) employed for execution of [TVM code](/tvm/instructions).                                                                                                                                                       |
+| `String`       | A UTF-8 string.                                                                                                                                                                                                                                         |
+| `Bytes`        | An arbitrary sequence of 8-bit bytes, typically used to represent binary data.                                                                                                                                                                          |
+| `Box`          | A container occupying one stack slot, that can be used to store one value of any type. Usually used to represent variables and mutable data structures.                                                                                                 |
+| `Atom`         | A simple entity uniquely identified by its name. Can be used to represent identifiers, labels, operation names, tags, and stack markers.                                                                                                                |
+| `Object`       | An arbitrary C++ object. Entities like word lists, execution tokens and Fift hashmaps are represented as having the type `Object`. This type may also be used by Fift extensions to manipulate other data types and interface with other C++ libraries. |
+
+The first seven types listed above are shared with TVM; the remainder are Fift-specific.
+
+<Aside
+  title="No boolean type"
+>
+  There is no dedicated `Boolean` type. Instead, booleans are represented as integers:
+
+  - "false" is `0`, "true" is `-1`, a 257-bit integer with all bits set to `1`.
+  - Logical operations are performed using bitwise operations.
+  - In conditional execution of blocks and loops with exit conditions, any nonzero integer in the conditions is regarded as "true".
+</Aside>
+
+<Aside
+  title="Tuples"
+>
+  Tuples can be used to represent values of arbitrary algebraic data types and Lisp-style lists. Refer to the Tuples section in the basic values page.
+</Aside>
+
+<Aside
+  title="The Object type"
+>
+  Many entities in Fift do not have a dedicated type, but they are assigned type `Object`. Fift provides words for creating and manipulating these entities. Examples of entities of type `Object`:
+
+  - Word list: A partially created list of word references, used for creating an execution token. See section for Blocks in the Control Flow page. See also Section [4.7](/languages/fift/whitepaper#4-7-creating-and-manipulating-word-lists) in the whitepaper for a list of words that create and manipulate word lists.
+  - Execution token: Fift code that can be executed and manipulated on the Fift stack. See section for Blocks in the Control Flow page for more details.
+  - Fift hashmap: A hashmap specific for Fift. These hashmaps are not represented as cells, contrary to TVM hashmaps. Refer to Fift hashmaps section in the Basic Values page. As a comparison with TVM hashmaps, refer to Section [6.3](/languages/fift/whitepaper#6-3-dictionary-manipulation) in the whitepaper for a list of words that create and manipulate TVM hashmaps.
+</Aside>