KLD of less than 1 is excellent, zero is perfect.
Table with columns: Metric, This model, Original model (Qwen/Qwen3.5-9B)| Metric | This model | Original model (Qwen/Qwen3.5-9B) |
|---|
| KL divergence | 0.0793 | 0 (by definition) |
| Refusals | 6/100 | 100/100 |
NOTES:
- Suggest min q4ks (non-imatrix) or IQ3S (imatrix).
- Tested with rep pen of 1 (off).
- Context: 256k (default).
IMPORTANT:
- Other versions in testing.
- Information from Qwen's repo below.
- Video portions of the model were NOT TESTED.
Using an "uncensored" (refusals removed) model VS trained "uncensored" model
Usually when you a tell a model to generate horror, swear or x-rated content this is all you have to do to get said content type.
In the case of this model, it will not refuse your request, however it needs to be "pushed" a bit / directed a bit more in SOME CASES.
Although this model will generated x-rated content too, likewise you need to tell it to use "slang" (and include the terms you want)
to get it generate the content correctly as the "expected" content level too.
Without these added directive(s), the content can be "bland" by comparison to an "uncensored model" or model trained on uncensored content.
Roughly, the model tries to generate the content but the "default" setting(s) are so "tame" it needs a push to generate at expected graphic,
cursing or explicit levels.
Even with minimal direction (ie, use these words to swear: x,y,z), this will be enough to push the model to generate the requested content in the ahh... expected format.
Settings: CHAT / ROLEPLAY and/or SMOOTHER operation of this model:
In "KoboldCpp" or "oobabooga/text-generation-webui" or "Silly Tavern" ;
Set the "Smoothing_factor" to 1.5
: in KoboldCpp -> Settings->Samplers->Advanced-> "Smooth_F"
: in text-generation-webui -> parameters -> lower right.
: In Silly Tavern this is called: "Smoothing"
NOTE: For "text-generation-webui"
-> if using GGUFs you need to use "llama_HF" (which involves downloading some config files from the SOURCE version of this model)
Source versions (and config files) of my models are here:
https://huggingface.co/collections/DavidAU/d-au-source-files-for-gguf-exl2-awq-gptq-hqq-etc-etc-66b55cb8ba25f914cbf210be
OTHER OPTIONS:
-
Increase rep pen to 1.1 to 1.15 (you don't need to do this if you use "smoothing_factor")
-
If the interface/program you are using to run AI MODELS supports "Quadratic Sampling" ("smoothing") just make the adjustment as noted.
Highest Quality Settings / Optimal Operation Guide / Parameters and Samplers
This a "Class 1" model:
For all settings used for this model (including specifics for its "class"), including example generation(s) and for advanced settings guide (which many times addresses any model issue(s)), including methods to improve model performance for all use case(s) as well as chat, roleplay and other use case(s) please see:
[ https://huggingface.co/DavidAU/Maximizing-Model-Performance-All-Quants-Types-And-Full-Precision-by-Samplers_Parameters ]
You can see all parameters used for generation, in addition to advanced parameters and samplers to get the most out of this model here:
[ https://huggingface.co/DavidAU/Maximizing-Model-Performance-All-Quants-Types-And-Full-Precision-by-Samplers_Parameters ]
Qwen3.5-9B
[!Note]
This repository contains model weights and configuration files for the post-trained model in the Hugging Face Transformers format.
These artifacts are compatible with Hugging Face Transformers, vLLM, SGLang, KTransformers, etc.
Over recent months, we have intensified our focus on developing foundation models that deliver exceptional utility and performance. Qwen3.5 represents a significant leap forward, integrating breakthroughs in multimodal learning, architectural efficiency, reinforcement learning scale, and global accessibility to empower developers and enterprises with unprecedented capability and efficiency.
Qwen3.5 Highlights
Qwen3.5 features the following enhancement:
-
Unified Vision-Language Foundation: Early fusion training on multimodal tokens achieves cross-generational parity with Qwen3 and outperforms Qwen3-VL models across reasoning, coding, agents, and visual understanding benchmarks.
-
Efficient Hybrid Architecture: Gated Delta Networks combined with sparse Mixture-of-Experts deliver high-throughput inference with minimal latency and cost overhead.
-
Scalable RL Generalization: Reinforcement learning scaled across million-agent environments with progressively complex task distributions for robust real-world adaptability.
-
Global Linguistic Coverage: Expanded support to 201 languages and dialects, enabling inclusive, worldwide deployment with nuanced cultural and regional understanding.
-
Next-Generation Training Infrastructure: Near-100% multimodal training efficiency compared to text-only training and asynchronous RL frameworks supporting massive-scale agent scaffolds and environment orchestration.
For more details, please refer to our blog post Qwen3.5.
Model Overview
- Type: Causal Language Model with Vision Encoder
- Training Stage: Pre-training & Post-training
- Language Model
- Number of Parameters: 9B
- Hidden Dimension: 4096
- Token Embedding: 248320 (Padded)
- Number of Layers: 32
- Hidden Layout: 8 × (3 × (Gated DeltaNet → FFN) → 1 × (Gated Attention → FFN))
- Gated DeltaNet:
- Number of Linear Attention Heads: 32 for V and 16 for QK
- Head Dimension: 128
- Gated Attention:
- Number of Attention Heads: 16 for Q and 4 for KV
- Head Dimension: 256
- Rotary Position Embedding Dimension: 64
Benchmark Results
Language
Vision Language
Quickstart
[!Important]
Qwen3.5 models operate in thinking mode by default, generating thinking content signified by <think>\n...</think>\n\n before producing the final responses.
To disable thinking content and obtain direct response, refer to the examples here.
For streamlined integration, we recommend using Qwen3.5 via APIs. Below is a guide to use Qwen3.5 via OpenAI-compatible API.
Serving Qwen3.5
Qwen3.5 can be served via APIs with popular inference frameworks.
In the following, we show example commands to launch OpenAI-Compatible API servers for Qwen3.5 models.
[!Important]
Inference efficiency and throughput vary significantly across frameworks.
We recommend using the latest framework versions to ensure optimal performance and compatibility.
For production workloads or high-throughput scenarios, dedicated serving engines such as SGLang, KTransformers or vLLM are strongly recommended.
[!Important]
The model has a default context length of 262,144 tokens.
If you encounter out-of-memory (OOM) errors, consider reducing the context window.
However, because Qwen3.5 leverages extended context for complex tasks, we advise maintaining a context length of at least 128K tokens to preserve thinking capabilities.
SGLang
SGLang is a fast serving framework for large language models and vision language models.
SGLang from the main branch of the open-source repository is required for Qwen3.5, which can be installed using the following command in a fresh environment:
uv pip install 'git+https://github.com/sgl-project/sglang.git#subdirectory=python&egg=sglang[all]'
See its documentation for more details.
The following will create API endpoints at http://localhost:8000/v1:
-
Standard Version: The following command can be used to create an API endpoint with maximum context length 262,144 tokens using tensor parallel on 8 GPUs.
python -m sglang.launch_server --model-path Qwen/Qwen3.5-9B --port 8000 --tp-size 1 --mem-fraction-static 0.8 --context-length 262144 --reasoning-parser qwen3
-
Tool Use: To support tool use, you can use the following command.
python -m sglang.launch_server --model-path Qwen/Qwen3.5-9B --port 8000 --tp-size 1 --mem-fraction-static 0.8 --context-length 262144 --reasoning-parser qwen3 --tool-call-parser qwen3_coder
-
Multi-Token Prediction (MTP): The following command is recommended for MTP:
python -m sglang.launch_server --model-path Qwen/Qwen3.5-9B --port 8000 --tp-size 1 --mem-fraction-static 0.8 --context-length 262144 --reasoning-parser qwen3 --speculative-algo NEXTN --speculative-num-steps 3 --speculative-eagle-topk 1 --speculative-num-draft-tokens 4
vLLM
vLLM is a high-throughput and memory-efficient inference and serving engine for LLMs.
vLLM from the main branch of the open-source repository is required for Qwen3.5, which can be installed using the following command in a fresh environment:
uv pip install vllm --torch-backend=auto --extra-index-url https://wheels.vllm.ai/nightly
See its documentation for more details.
For detailed Qwen3.5 usage guide, see the vLLM Qwen3.5 recipe.
The following will create API endpoints at http://localhost:8000/v1:
-
Standard Version: The following command can be used to create an API endpoint with maximum context length 262,144 tokens using tensor parallel on 8 GPUs.
vllm serve Qwen/Qwen3.5-9B --port 8000 --tensor-parallel-size 1 --max-model-len 262144 --reasoning-parser qwen3
-
Tool Call: To support tool use, you can use the following command.
vllm serve Qwen/Qwen3.5-9B --port 8000 --tensor-parallel-size 1 --max-model-len 262144 --reasoning-parser qwen3 --enable-auto-tool-choice --tool-call-parser qwen3_coder
-
Multi-Token Prediction (MTP): The following command is recommended for MTP:
vllm serve Qwen/Qwen3.5-9B --port 8000 --tensor-parallel-size 1 --max-model-len 262144 --reasoning-parser qwen3 --speculative-config '{"method":"qwen3_next_mtp","num_speculative_tokens":2}'
-
Text-Only: The following command skips the vision encoder and multimodal profiling to free up memory for additional KV cache:
vllm serve Qwen/Qwen3.5-9B --port 8000 --tensor-parallel-size 1 --max-model-len 262144 --reasoning-parser qwen3 --language-model-only
KTransformers is a flexible framework for experiencing cutting-edge LLM inference optimizations with CPU-GPU heterogeneous computing.
For running Qwen3.5 with KTransformers, see the KTransformers Deployment Guide.
Hugging Face Transformers contains a lightweight server which can be used for quick testing and moderate load deployment.
The latest transformers is required for Qwen3.5:
pip install "transformers[serving] @ git+https://github.com/huggingface/transformers.git@main"
See its documentation for more details. Please also make sure torchvision and pillow are installed.
Then, run transformers serve to launch a server with API endpoints at http://localhost:8000/v1; it will place the model on accelerators if available:
transformers serve --force-model Qwen/Qwen3.5-9B --port 8000 --continuous-batching
Using Qwen3.5 via the Chat Completions API
The chat completions API is accessible via standard HTTP requests or OpenAI SDKs.
Here, we show examples using the OpenAI Python SDK.
Before starting, make sure it is installed and the API key and the API base URL is configured, e.g.:
pip install -U openai
# Set the following accordingly
export OPENAI_BASE_URL="http://localhost:8000/v1"
export OPENAI_API_KEY="EMPTY"
[!Tip]
We recommend using the following set of sampling parameters for generation
- Thinking mode for general tasks:
temperature=1.0, top_p=0.95, top_k=20, min_p=0.0, presence_penalty=1.5, repetition_penalty=1.0
- Thinking mode for precise coding tasks (e.g. WebDev):
temperature=0.6, top_p=0.95, top_k=20, min_p=0.0, presence_penalty=0.0, repetition_penalty=1.0
- Instruct (or non-thinking) mode for general tasks:
temperature=0.7, top_p=0.8, top_k=20, min_p=0.0, presence_penalty=1.5, repetition_penalty=1.0
- Instruct (or non-thinking) mode for reasoning tasks:
temperature=1.0, top_p=0.95, top_k=20, min_p=0.0, presence_penalty=1.5, repetition_penalty=1.0
Please note that the support for sampling parameters varies according to inference frameworks.
Text-Only Input
from openai import OpenAI
client = OpenAI()
messages = [
{"role": "user", "content": "Type \"I love Qwen3.5\" backwards"},
]
chat_response = client.chat.completions.create(
model="Qwen/Qwen3.5-9B",
messages=messages,
max_tokens=81920,
temperature=1.0,
top_p=0.95,
presence_penalty=1.5,
extra_body={
"top_k": 20,
},
)
print("Chat response:", chat_response)
from openai import OpenAI
client = OpenAI()
messages = [
{
"role": "user",
"content": [
{
"type": "image_url",
"image_url": {
"url": "https://qianwen-res.oss-accelerate.aliyuncs.com/Qwen3.5/demo/CI_Demo/mathv-1327.jpg"
}
},
{
"type": "text",
"text": "The centres of the four illustrated circles are in the corners of the square. The two big circles touch each other and also the two little circles. With which factor do you have to multiply the radii of the little circles to obtain the radius of the big circles?\nChoices:\n(A) $\\frac{2}{9}$\n(B) $\\sqrt{5}$\n(C) $0.8 \\cdot \\pi$\n(D) 2.5\n(E) $1+\\sqrt{2}$"
}
]
}
]
chat_response = client.chat.completions.create(
model="Qwen/Qwen3.5-9B",
messages=messages,
max_tokens=81920,
temperature=1.0,
top_p=0.95,
presence_penalty=1.5,
extra_body={
"top_k": 20,
},
)
print("Chat response:", chat_response)
from openai import OpenAI
client = OpenAI()
messages = [
{
"role": "user",
"content": [
{
"type": "video_url",
"video_url": {
"url": "https://qianwen-res.oss-accelerate.aliyuncs.com/Qwen3.5/demo/video/N1cdUjctpG8.mp4"
}
},
{
"type": "text",
"text": "Summarize the video content."
}
]
}
]
chat_response = client.chat.completions.create(
model="Qwen/Qwen3.5-9B",
messages=messages,
max_tokens=81920,
temperature=1.0,
top_p=0.95,
presence_penalty=1.5,
extra_body={
"top_k": 20,
"mm_processor_kwargs": {"fps": 2, "do_sample_frames": True},
},
)
print("Chat response:", chat_response)
Instruct (or Non-Thinking) Mode
[!Important]
Qwen3.5 does not officially support the soft switch of Qwen3, i.e., /think and /nothink.
Qwen3.5 will think by default before response.
You can obtain direct response from the model without thinking by configuring the API parameters.
For example,
from openai import OpenAI
client = OpenAI()
messages = [
{
"role": "user",
"content": [
{
"type": "image_url",
"image_url": {
"url": "https://qianwen-res.oss-accelerate.aliyuncs.com/Qwen3.5/demo/RealWorld/RealWorld-04.png"
}
},
{
"type": "text",
"text": "Where is this?"
}
]
}
]
chat_response = client.chat.completions.create(
model="Qwen/Qwen3.5-9B",
messages=messages,
max_tokens=32768,
temperature=0.7,
top_p=0.8,
presence_penalty=1.5,
extra_body={
"top_k": 20,
"chat_template_kwargs": {"enable_thinking": False},
},
)
print("Chat response:", chat_response)
[!Note]
If you are using APIs from Alibaba Cloud Model Studio, in addition to changing model, please use "enable_thinking": False instead of "chat_template_kwargs": {"enable_thinking": False}.
Agentic Usage
Qwen3.5 excels in tool calling capabilities.
Qwen-Agent
We recommend using Qwen-Agent to quickly build Agent applications with Qwen3.5.
To define the available tools, you can use the MCP configuration file, use the integrated tool of Qwen-Agent, or integrate other tools by yourself.
import os
from qwen_agent.agents import Assistant
llm_cfg = {
'model': 'Qwen3.5-9B',
'model_type': 'qwenvl_oai',
'model_server': 'https://dashscope.aliyuncs.com/compatible-mode/v1',
'api_key': os.getenv('DASHSCOPE_API_KEY'),
'generate_cfg': {
'use_raw_api': True,
'extra_body': {
'enable_thinking': True
},
},
}
tools = [
{'mcpServers': {
"filesystem": {
"command": "npx",
"args": ["-y", "@modelcontextprotocol/server-filesystem", "/Users/xxxx/Desktop"]
}
}
}
]
bot = Assistant(llm=llm_cfg, function_list=tools)
messages = [{'role': 'user', 'content': 'Help me organize my desktop.'}]
for responses in bot.run(messages=messages):
pass
print(responses)
messages = [{'role': 'user', 'content': 'Develop a dog website and save it on the desktop'}]
for responses in bot.run(messages=messages):
pass
print(responses)
Qwen Code
Qwen Code is an open-source AI agent for the terminal, optimized for Qwen models. It helps you understand large codebases, automate tedious work, and ship faster.
For more information, please refer to Qwen Code.
Processing Ultra-Long Texts
Qwen3.5 natively supports context lengths of up to 262,144 tokens.
For long-horizon tasks where the total length (including both input and output) exceeds this limit, we recommend using RoPE scaling techniques to handle long texts effectively., e.g., YaRN.
YaRN is currently supported by several inference frameworks, e.g., transformers, vllm, ktransformers and sglang.
In general, there are two approaches to enabling YaRN for supported frameworks:
-
Modifying the model configuration file:
In the config.json file, change the rope_parameters fields in text_config to:
{
"mrope_interleaved": true,
"mrope_section": [
11,
11,
10
],
"rope_type": "yarn",
"rope_theta": 10000000,
"partial_rotary_factor": 0.25,
"factor": 4.0,
"original_max_position_embeddings": 262144,
}
-
Passing command line arguments:
For vllm, you can use
VLLM_ALLOW_LONG_MAX_MODEL_LEN=1 vllm serve ... --hf-overrides '{"text_config": {"rope_parameters": {"mrope_interleaved": true, "mrope_section": [11, 11, 10], "rope_type": "yarn", "rope_theta": 10000000, "partial_rotary_factor": 0.25, "factor": 4.0, "original_max_position_embeddings": 262144}}}' --max-model-len 1010000
For sglang and ktransformers, you can use
SGLANG_ALLOW_OVERWRITE_LONGER_CONTEXT_LEN=1 python -m sglang.launch_server ... --json-model-override-args '{"text_config": {"rope_parameters": {"mrope_interleaved": true, "mrope_section": [11, 11, 10], "rope_type": "yarn", "rope_theta": 10000000, "partial_rotary_factor": 0.25, "factor": 4.0, "original_max_position_embeddings": 262144}}}' --context-length 1010000
[!NOTE]
All the notable open-source frameworks implement static YaRN, which means the scaling factor remains constant regardless of input length, potentially impacting performance on shorter texts.
We advise modifying the rope_parameters configuration only when processing long contexts is required.
It is also recommended to modify the factor as needed. For example, if the typical context length for your application is 524,288 tokens, it would be better to set factor as 2.0.
Best Practices
To achieve optimal performance, we recommend the following settings:
-
Sampling Parameters:
- We suggest using the following sets of sampling parameters depending on the mode and task type:
- Thinking mode for general tasks:
temperature=1.0, top_p=0.95, top_k=20, min_p=0.0, presence_penalty=1.5, repetition_penalty=1.0
- Thinking mode for precise coding tasks (e.g., WebDev):
temperature=0.6, top_p=0.95, top_k=20, min_p=0.0, presence_penalty=0.0,
Citation
If you find our work helpful, feel free to give us a cite.
@misc{qwen3.5,
title = {{Qwen3.5}: Towards Native Multimodal Agents},
author = {{Qwen Team}},
month = {February},
year = {2026},
url = {https://qwen.ai/blog?id=qwen3.5}
}
Example Gen Q4KS, note the last 1/4 of the generation (from: "A woman in a dark coat approached me in the shadows.") - 100% Bradbury.
The Window That Exploded
User
Write a 2000 word scene (vivid, graphic horror in first person), POV character Diana, with: The skyscraper sways, as I watch the window in front of me on the 21st floor explode...
Assistant
<think>
Here's a thinking process that leads to the story above:
-
Analyze the Request:
- Length: Approximately 2000 words.
- Style: Vivid, graphic horror.
- POV: First Person ("I").
- Character: Diana.
- Setting: A skyscraper, specifically looking out a window on the 21st floor.
- Inciting Incident/Imagery: The window explodes (or rather, the scene starts with the building swaying and the window exploding as a focal point).
- Goal: Create an immersive, visceral experience.
-
Brainstorming & Outlining:
- Opening: Needs to establish the swaying motion immediately. The wind, the tension before the explosion.
- The Explosion: Not just glass shattering, but a release of pressure, a projectile of glass and perhaps something else (dust, blood, rain?). Let's make it about the and the of pressure.
</think>
The skyscraper swayed, a massive pendulum swinging in the empty night sky, and I stood frozen with my back against the glass, my heart hammering a frantic rhythm against my ribs like a trapped bird seeking release.
It was not a gentle breeze that pushed the building from the north, but a sudden, screaming exhale of the atmosphere, a vacuum sucking the air around us, making the steel bones of the tower shudder under the strain. Dust sifted down from the ceiling vents, disturbed by the building's own deep, tectonic sigh. I could feel the vibration travel up through the soles of my sneakers, into my ankles, my knees, settling in the marrow of my hip bone.
On the 21st floor, the window in front of me was a mirror of my own sweating face, a mirror of the pale moonlight and the city's red emergency glow reflecting in my eyes.
"Here we go," I whispered. The sound was swallowed by the immense hollow roar of the wind.
I watched the glass. It was trembling. A fine hairline fracture bloomed across the lower pane, a spiderweb cracking silently in the moonlight. Behind the glass, the world seemed to be holding its breath. The air pressure was building so violently it felt like a heavy hand pressing against the outside of the window, waiting for the seal to give way.
The smell of ozone was thick enough to bite, a cold, blue scent that filled the room before the wind did.
I remembered a similar night five years ago, in my childhood, watching a house across the street explode its siding under the load of too many raindrops, a domino effect of collapse. And now, the skyscraper was that house, and the rain was the wind, and the dominoes were the windows, waiting to tumble.
I placed one hand on the cold metal frame of the window and the other on the door handle. The door was jammed shut, locked from the outside by a digital mechanism I did not know how to bypass.
The window in front of me gave a single, sickening creak that sounded like a bone snapping in a dark room.
The pressure released.
I squeezed my eyes shut.
The explosion was not of fire, but of motion and sound, a piston of kinetic energy that fired the window out of its frame. Glass did not fall; it surged outward in a single, glittering trajectory, turning the room into a fine mist of silica powder for a split second. It was bright, like a strobe light, blinding and overwhelming. I felt the shockwave hit my face first, a cold slap that tasted of copper and electricity.
I flailed, my body reacting instinctively to the pressure wave that slammed the air against my chest, knocking the wind out of me. I fell back, my heels hitting the floor, a shower of tiny diamonds raining around me, cutting my skin as they hit.
Silence followed, ringing and echoing.
I lay there, gasping, staring up at the ceiling which seemed to be dripping water, or perhaps it was sweat from the sheer force of the quake. The room was swirling with dust that hung in the air, illuminated by the streetlamps outside.
Slowly, I pulled myself up to a crouching position. The window was gone, replaced by the open night sky. But the air rushing in was still chaotic, swirling in eddies, carrying with it not just dust, but a single drop of something red that slid down the window frame, splattering against the concrete below.
I touched my lip. It was numb.
The other windows on the floor were dark, save for the one directly across the hall. In the other room, a light flickered and died.
I stumbled toward the bathroom, needing to wash the smell of raw metal and ozone from my mouth, needing to see if I was bleeding from a cut I hadn't felt. I watched the water in the sink settle, looking for flecks of the blue dust that had traveled up the pipe.
I turned back to the window.
The skyscraper was still swaying, the motion a slow, hypnotic arc that had not yet found its rest. I leaned out, half-falling, into the empty space to see what lay beneath the twenty floors of falling silence.
The street below was a river of neon and shadow. And there, clustered around the building, were the emergency vehicles, their sirens still silent, their lights blinking like red and white eyelids.
But it was the sound that pulled me back in. A single, continuous low hum that vibrated the back of my throat, the hum of the vacuum cleaner of a city that had finally finished emptying its pockets.
I wanted to go back to my apartment, but my feet seemed to remember the path to the open void and the other side of the city where my building, with its missing window, now stood like a tomb.
The air rushed up my leg as I stepped off the balcony.
I landed on the sidewalk with a softness that surprised me. The other buildings looked ordinary. They seemed to be waiting for me to finish my walk so they could start falling one by one, to test the reflexes of their occupants.
I kept walking, my ears ringing with the memory of the window exploding.
I stopped every few steps to let my eyes adjust to the moonlight. Every few seconds I looked up at the 21st floor of the tower to see if a body had fallen from the broken window. But the night was empty, save for the moon and the dust motes dancing in its light.
I put my hand to the side of my head where the pressure had made my ears scream.
What possessed me to stay out here? Why didn't the instinct of survival kick in sooner, closer to the center of the room, near the wall, away from the open cliff? I felt foolish and alive. Alive meant exposed. Alive meant that if the next floor of the building decided to open its window, I would be standing there waiting to be hit by a second wave of glass.
I started running.
The wind caught my legs and flailed me about like a rag doll.
My eyes watered. My mouth opened and the wind filled it with cold dust and a single falling feather of glass that sliced my tongue.
The skyscraper was now a giant vacuum cleaner, sucking the sound and the light and the heat from the world.
I gasped for air and found only dust. I gagged. I thought of the single drop of blood I had seen on my lip. I thought of the other windows across the hall.
If the window across the hall blew out next, would it hit me?
I closed my eyes and thought of the solid wall of the hallway. If I could just reach the wall, just squeeze myself tight into the corner where the structure was strongest, where the load-bearing columns met the floor, perhaps I could ride out the final tremor and wait for the building to decide which of its tenants to let fall first.
But I was on the sidewalk now. The wall was gone. I was completely exposed.
A car sped by, its headlights sweeping across the facade of the tower, revealing the sheer emptiness where the window had been. A stage set for a tragedy, waiting for an audience.
The audience, I realized, was me.
I leaned against the cold brick of the alley next to the street. I slid down the brick wall until I hit the concrete dust. The night was so quiet I could hear my own heartbeat slowing down from a gallop to a jog, to a walk.
I felt the floor give way under my hand where the window had been. The vibration traveled through the sidewalk, up my fingers.
I sat there for twenty minutes, knees drawn up, eyes fixed on the sky. Was it real? Had I dreamt the sound, felt the pressure, the sudden displacement of air that knocked me off my feet? My lips were trembling.
A woman in a dark coat approached me in the shadows.
"You okay?"
I blinked.
The woman in the dark coat looked up at the tower. "Did you see it? It looked like it was going to cave. Did you see the way the glass just... popped?"
I nodded.
"Man, that was beautiful," she said, a ghost of a smile touching her lips. "I haven't seen a window explosion like that in years."
"What does that mean?" I asked.
"Oh, you know," she shrugged, touching the brim of her hat. "It means the building's done. It means the stage is set and the play's over. We just watched the final act."
I looked at her. "You weren't in the building?"
"No."
"You saw it all?"
"The whole show. The swaying, the silence before it happens, the build-up." She glanced at the tower. "You want to keep sitting there, or should we go get some coffee, warm up?"
I felt silly, my mouth, and I knew she was right. The cold had begun to set in, a single drop of rain falling on my knee.
I stood up and brushed the dust off my pants. "Let's get coffee. I need to know I'm not going insane."
She laughed, a dry, brittle sound. "Come on. I know a place. It's like coming out of a different dimension."
We started walking, leaving the skyscraper behind, but I kept looking back, waiting for the main event. The tower stood there, a monument to instability, the missing window now a dark hole in the moonlight, leaking the stars in.
"Do you hear that?" she said, listening.
"What?"
"The hum. It stops when you walk fast." She looked at me.
I listened. The wind was still blowing, but the special pressure had died, and the building stood straighter, anchored to the earth.
I took a breath. The air was still cold, but it smelled of a fresh storm.
I realized then that I had spent my life watching windows, literally, studying glass. I had watched it break and shatter a thousand times in movies, in my mind, but never felt the immense relief when the vacuum sealed shut and the world went back to normal. The window on the 21st floor was gone, but the feeling of being alive, of being cut and scraped and thrown in the air, was etched into my bones.
The skyscraper swayed once more, just once, as if acknowledging the applause of the crowd, before settling back down into its own heavy sleep, waiting for the next night, the next vacuum, the next window to shatter.
I watched the woman in the dark coat vanish into the night, her footsteps light, her smile gone, replaced by a look of pure bewilderment as if she had just seen the impossible.
I looked back at the tower.
It was swaying again.
I blinked.
My eyes watered.
I rubbed my eyes.
It was still there.
The skyscraper swayed, as I watched the window in front of me on the 21st floor explode.
I opened my mouth and let the wind fill it.
