diff --git a/examples/forin.ast b/examples/forin.ast
index cd7476b..53e3fba 100644
--- a/examples/forin.ast
+++ b/examples/forin.ast
@@ -5,13 +5,11 @@ for (x in arr) {
     print(x)
 }
 
-print("=== object keys ===")
+print("=== object keys + values ===")
 let obj = {name: "Aster", year: 2025}
-let keys = ""
 for (k in obj) {
-    keys = keys + k + " "
+    print(k + ": " + obj[k])
 }
-print(keys)
 
 print("=== string chars ===")
 for (c in "Hi") {
diff --git a/src/interpreter/interpreter.rs b/src/interpreter/interpreter.rs
index 9f54414..5d791a0 100644
--- a/src/interpreter/interpreter.rs
+++ b/src/interpreter/interpreter.rs
@@ -244,10 +244,24 @@ impl Interpreter {
                 }
             }
             Expr::IndexGet { array, index } => {
-                let arr = self.evaluate(*array)?;
-                let idx = self.evaluate(*index)?;
-                let i = self.as_array_index(&idx)?;
-                match arr {
+                let target = self.evaluate(*array)?;
+                let idx_val = self.evaluate(*index)?;
+                // Object index access: obj["key"]
+                if let Value::Object(map) = &target {
+                    let key = match &idx_val {
+                        Value::String(s) => s.clone(),
+                        _ => return Err(RuntimeError::RuntimeError {
+                            message: "Object index must be a string".into(),
+                            token: None,
+                        }),
+                    };
+                    return map.borrow().get(&key).cloned().ok_or_else(|| RuntimeError::RuntimeError {
+                        message: format!("Undefined property '{}'", key),
+                        token: None,
+                    });
+                }
+                let i = self.as_array_index(&idx_val)?;
+                match target {
                     Value::Array(vec) => {
                         let vec = vec.borrow();
                         vec.get(i).cloned().ok_or_else(|| RuntimeError::RuntimeError {
@@ -263,17 +277,40 @@ impl Interpreter {
                         })
                     }
                     _ => Err(RuntimeError::RuntimeError {
-                        message: "Index access on non-array, non-string value".to_string(),
+                        message: "Index access on non-array, non-string, non-object value".to_string(),
                         token: None,
                     }),
                 }
             }
             Expr::IndexSet { array, index, op, value } => {
-                let arr = self.evaluate(*array)?;
-                let idx = self.evaluate(*index)?;
+                let target = self.evaluate(*array)?;
+                let idx_val = self.evaluate(*index)?;
                 let rhs = self.evaluate(*value)?;
-                let i = self.as_array_index(&idx)?;
-                match arr {
+                // Object index assignment: obj["key"] = value
+                if let Value::Object(map) = &target {
+                    let key = match &idx_val {
+                        Value::String(s) => s.clone(),
+                        _ => return Err(RuntimeError::RuntimeError {
+                            message: "Object index must be a string".into(),
+                            token: None,
+                        }),
+                    };
+                    let val = match op {
+                        AssignOp::Equal => rhs,
+                        _ => {
+                            let map_borrow = map.borrow();
+                            let current = map_borrow.get(&key).ok_or_else(|| RuntimeError::RuntimeError {
+                                message: format!("Property '{}' does not exist", key),
+                                token: None,
+                            })?;
+                            self.apply_assign_op(current.clone(), rhs, op)?
+                        }
+                    };
+                    map.borrow_mut().insert(key, val.clone());
+                    return Ok(val);
+                }
+                let i = self.as_array_index(&idx_val)?;
+                match target {
                     Value::Array(vec) => {
                         let mut vec = vec.borrow_mut();
                         if i >= vec.len() {
@@ -293,7 +330,7 @@ impl Interpreter {
                         Ok(val)
                     }
                     _ => Err(RuntimeError::RuntimeError {
-                        message: "Index assignment on non-array value".to_string(),
+                        message: "Index assignment on non-array, non-object value".to_string(),
                         token: None,
                     }),
                 }
@@ -1458,6 +1495,89 @@ mod tests {
         assert!(result.is_err(), "Expected error for index on non-array");
     }
 
+    // =========================================================================
+    // Object index access: obj[key]
+    // =========================================================================
+
+    #[test]
+    fn eval_object_index_get() {
+        assert_num(&eval_expr("{a: 42}[\"a\"]"), 42.0);
+    }
+
+    #[test]
+    fn eval_object_index_get_nested() {
+        assert_num(&eval_expr("{inner: {val: 7}}[\"inner\"][\"val\"]"), 7.0);
+    }
+
+    #[test]
+    fn eval_object_index_get_variable_key() {
+        let interp = run("let obj = {x: 10, y: 20}; let k = \"y\"; let result = obj[k];");
+        assert_num(&get_var(&interp, "result"), 20.0);
+    }
+
+    #[test]
+    fn eval_object_index_get_undefined() {
+        let result = std::panic::catch_unwind(|| {
+            eval_expr("{}[\"x\"]");
+        });
+        assert!(result.is_err(), "Expected error for undefined property");
+    }
+
+    #[test]
+    fn eval_object_index_set_existing() {
+        let interp = run("let obj = {a: 1}; obj[\"a\"] = 99;");
+        match get_var(&interp, "obj") {
+            Value::Object(map) => {
+                let map = map.borrow();
+                assert_num(map.get("a").unwrap(), 99.0);
+            }
+            v => panic!("Expected Object, got {:?}", v),
+        }
+    }
+
+    #[test]
+    fn eval_object_index_set_new_key() {
+        let interp = run("let obj = {}; obj[\"name\"] = \"Aster\";");
+        match get_var(&interp, "obj") {
+            Value::Object(map) => {
+                let map = map.borrow();
+                match map.get("name").unwrap() {
+                    Value::String(s) => assert_eq!(s, "Aster"),
+                    v => panic!("Expected String, got {:?}", v),
+                }
+            }
+            v => panic!("Expected Object, got {:?}", v),
+        }
+    }
+
+    #[test]
+    fn eval_object_index_compound_assign() {
+        let interp = run("let obj = {count: 10}; obj[\"count\"] += 5;");
+        match get_var(&interp, "obj") {
+            Value::Object(map) => {
+                let map = map.borrow();
+                assert_num(map.get("count").unwrap(), 15.0);
+            }
+            v => panic!("Expected Object, got {:?}", v),
+        }
+    }
+
+    #[test]
+    fn error_object_index_non_string() {
+        let result = std::panic::catch_unwind(|| {
+            eval_expr("{a: 1}[42]");
+        });
+        assert!(result.is_err(), "Expected error for non-string object index");
+    }
+
+    #[test]
+    fn error_object_index_set_non_string() {
+        let result = std::panic::catch_unwind(|| {
+            eval_expr("let obj = {a: 1}; obj[true] = 2;");
+        });
+        assert!(result.is_err(), "Expected error for non-string object index set");
+    }
+
     // =========================================================================
     // Builtins: len
     // =========================================================================