Config Reference config.json
V2Ray Configuration Guide
Trace a request from its local listening port through tags, rules, and connection policies to the outbound actually used by the core.
This page is organized by configuration field. If you haven’t installed a client yet, or just need to import a profile and make your first connection, follow the Getting Started guide first, then return here to check the configuration generated by the client.
JSON Structure Overview
Client Settings vs. Core Configuration
The client stores nodes, subscriptions, interface options, and operating modes. The core reads the configuration loaded at startup. They’re related, but they aren’t the same file. For example, the client’s “system proxy” setting determines whether an application sends requests to the local proxy. The core’s routing rules determine what happens to requests it has already received. Changing routing won’t make an application that doesn’t use the proxy start sending proxy requests.
For desktop, choose v2rayN from the client downloads page. On Android, you can use v2rayNG or v2flyNG. When reviewing a config, first confirm which core is actually running, then check its fields. Xray and V2Fly share much of the same structure, but protocol options, transport parameters, and resource files aren’t interchangeable field for field. A core’s ability to read a config doesn’t mean the client will import or preserve it the same way.
First identify whether you have a node export, a complete core config, or a client settings backup. A node export describes a remote server; it doesn’t define local listening ports. A client backup may combine interface preferences and multiple nodes, so it can’t be passed directly to the core. Troubleshoot the config used by the current run. If the client regenerates the file, change the corresponding setting in its interface or use a custom-config option supported by the client.
Top-Level Object, Arrays, and Tag References
The root is an object. inbounds and outbounds are arrays because a process can have multiple listeners and outbound connections. routing is an object, with its rule array inside rules. dns and policy are also objects. Don’t nest sibling fields inside the previous field’s settings just because each section uses braces.
| Field | Structure | Purpose |
|---|---|---|
inbounds | Array | Defines the listening address, port, and protocol to accept. |
outbounds | Array | Defines direct, blocked, or remote-proxy connections; the first entry is the default outbound. |
routing | Object | Evaluates rules in order and sends matching requests to an outbound or balancer. |
dns | Object | Provides static records and resolvers for components that need built-in DNS resolution. |
policy | Object | Sets session constraints by level and enables statistics as needed. |
A tag isn’t a protocol name or an array index. Naming an outbound direct doesn’t make it connect directly; freedom is what performs a direct connection. Routing looks up tags by string. When renaming an outbound, search for and update every reference. Changing only the definition can break config validation or request routing. Distinct prefixes for inbound and outbound tags also make their direction easier to identify in logs.
Object property order usually doesn’t affect behavior, but array order can. Moving routing rules changes which one matches first; moving the first outbound changes where unmatched traffic goes. You can standardize indentation, but don’t sort every array alphabetically. When comparing two files, check array positions first, then look for added or removed fields.
A Standalone Starting Point
Here’s a basic config you can save and run on its own. It accepts SOCKS requests from the local machine and connects directly from that same device, without a remote node or routing resources. Before testing, stop any client using the same port, or change the example port along with the proxy port in your test tool. Unless noted otherwise, later code snippets are separate additions to the same root object. Don’t concatenate snippets that each have their own root braces.
{
"log": { "loglevel": "warning" },
"inbounds": [
{
"tag": "local-socks",
"listen": "127.0.0.1",
"port": 10808,
"protocol": "socks",
"settings": { "auth": "noauth", "udp": false }
}
],
"outbounds": [
{ "tag": "direct", "protocol": "freedom" }
]
}
The example uses strict JSON: keys and strings need double quotes, the last item in an array or object must not have a trailing comma, and keys at the same level must be unique. Write ports as integers, switches as booleans, and enum values exactly as accepted by the core. If both top-level configs contain routing, merge the rules deliberately and set their order—don’t keep two keys with the same name. Duplicate keys may not trigger a syntax error: some parsers overwrite the earlier value, leaving a file that looks complete but uses only the later section.
inbounds Inbound Listeners
Binding Addresses and Connection Endpoints
An inbound is the first connection from an application into the core. listen selects the local address to bind to, port selects the port, and protocol specifies the format sent by the client. All three must match. If an application points to the device’s LAN address but the process listens only on loopback, the connection won’t work even if the port is the same. A wrong protocol may establish the socket connection, then fail during the proxy handshake.
For local use, bind explicitly to 127.0.0.1 and enter the same address in the application. An application using localhost may try the IPv6 loopback address first, while this example listens only on IPv4, so avoid mixing the two when comparing failures. If testing another listening address, make sure it belongs to the local machine, the port is available, and you know who can access it. Don’t use a wildcard bind as a substitute for diagnosing a failed connection.
Two processes binding the same address and port can conflict, including a client’s bundled core and a manually started test process. If the port is occupied, first check whether the process holding it is the old instance that’s already working. Don’t terminate an unknown process. If you choose a different test port, update the application proxy, core listener, and test command together. Sending requests to the old port after changing the config can make it look as though the new config is active when it isn’t.
Separate SOCKS and HTTP Inbounds
This snippet can replace the basic config’s inbounds array. Both listeners use the same outbound configuration, but have different ports and inbound protocols. Set the second address and port in an HTTP proxy app; use the first for an app that supports SOCKS5. The inbound tag can be used to match traffic by source in routing rules. Whether an application uses the system proxy depends on the app and its environment; having a second listener doesn’t guarantee it will.
{
"inbounds": [
{
"tag": "local-socks",
"listen": "127.0.0.1",
"port": 10808,
"protocol": "socks",
"settings": { "auth": "noauth", "udp": false }
},
{
"tag": "local-http",
"listen": "127.0.0.1",
"port": 10809,
"protocol": "http"
}
]
}
An HTTP proxy can handle HTTP proxy requests from a client. Clients that support tunneling can also send CONNECT requests. Neither means the listener accepts arbitrary data formats. An application expecting SOCKS sends a SOCKS handshake, so an HTTP proxy port can’t be used as a SOCKS port. First configure a proxy explicitly in a single application, then check the system proxy settings. This helps distinguish an operating-system forwarding issue from a listener issue.
The SOCKS inbound’s udp setting controls whether SOCKS UDP relay is allowed. It doesn’t automatically send ordinary UDP datagrams from an application to this port. The application must implement SOCKS UDP association, and the outbound must handle the traffic using the appropriate protocol. A successful webpage test usually proves only that the test’s TCP path works. If a UDP-based feature fails, verify its inbound, routing, and outbound separately; don’t assume they’re working just because the same device can open a webpage.
Target Detection and Traffic Capture
The target received by an inbound may be a domain name or an IP address. If an application resolves the name before sending the request, routing can’t compare the IP directly with the original domain. Some cores can identify target names in certain protocols using inbound sniffing, but detection depends on the traffic format and what information is visible. Before enabling it, check whether you need to add a routing condition or actually replace the connection target. Those are different effects.
Don’t treat target detection as a catch-all fix for routing problems. First test domain rules with a proxy request that explicitly includes the domain. If it still doesn’t match, check rule syntax and order. Only if the domain request works but the application sends an IP should you investigate target detection or the application’s proxy settings. Change one extra option at a time so you don’t alter both the routing input and the actual connection target at once.
System proxy, in-app proxy, and TUN are different traffic entry paths. The system proxy provides an address to applications that read the relevant settings. TUN captures selected traffic through a virtual network interface and involves system routes and permissions. If an application isn’t reaching a regular inbound, check its entry path before changing the outbound again. If a virtual network interface is enabled and a standard proxy test behaves unexpectedly, review the TUN mode guide, then retest with just one entry path enabled.
outbounds Outbound Protocols
Default Outbound and Explicit Blocking
An outbound determines where a request goes and which protocol is used for the next connection. freedom connects directly to the current request’s target using the network path available to the device running the core. It isn’t a remote node and can’t change the system gateway. blackhole actively discards matching requests. Both can help test routing, but only the former should make an actual connection to the target service.
This example adds a blocking option to the basic config’s outbounds. The entry won’t block traffic on its own unless a routing rule refers to deny. The example keeps direct first, so requests without a matching rule connect directly. Move deny to the first position and unmatched traffic will be blocked. That changes the default path, not just one setting. Before changing the order, check whether management traffic or everyday apps rely on the current default.
{
"outbounds": [
{ "tag": "direct", "protocol": "freedom" },
{ "tag": "deny", "protocol": "blackhole" }
]
}
Understand “direct” in the context of the inbound. An application first connects to the core, which then connects to the target using the outbound. That’s not the same path as an application that bypasses the proxy entirely; the two may use different resolvers, address families, and timeouts. In a comparison test, record both “didn’t enter the core” and “entered the core, then connected directly.” If only the latter fails, check the target received by the core and its runtime environment—not just whether the system can open the same URL.
Remote Address, Proxy Protocol, and Transport
A remote proxy has at least three layers: the server address and port to connect to, the proxy protocol spoken over that connection, and the underlying transport and security settings. The address and port reach the server; the proxy protocol defines details such as authentication; and the transport fields select how the connection is carried. Getting one layer working doesn’t guarantee the next will. You might reach the server’s port but fail to establish a session because the protocol or transport doesn’t match.
When reviewing a VLESS or other outbound, check protocol-specific settings separately from shared streamSettings. The node address is the first destination the client dials. If TLS is enabled, the name used in the handshake is for validating that connection; don’t blindly replace it with the website’s domain. Match the proxy protocol, transport type, security type, and corresponding server fields one by one. Don’t copy an entire transport configuration from a different node type.
When you receive a shared config, first check whether it imports a single remote node or a complete runtime config. Even a complete node entry still needs the client to generate listeners and routing. A full config may already define local ports and a default outbound. For the first test, enable one known-working remote only and leave advanced routing settings unchanged. Once the same request passes reliably through that outbound, add it to multi-outbound rules. This makes it easier to tell whether a later failure comes from the node or the selection logic.
Identity fields and subscription URLs in remote entries are management data. Don’t paste raw client exports into public discussions. To discuss a handshake failure, share only the core type, proxy protocol, transport type, outbound tag, and logs with identifying details removed. For a comparison across protocols, see VMess and VLESS field differences; don’t assume one protocol’s options map directly to equivalent options in another.
Changing a Tag Doesn’t Enable Failover
Use unique, easy-to-distinguish outbound tags within a config. Adding another remote to the array doesn’t create automatic failover; routing still sends requests only to the selected outbound. If that outbound can’t connect, the core won’t switch to a direct connection just because one appears later in the list. For failover, check the balancing features, candidate outbounds, and health-check conditions supported by your core. Simply adding another entry at the end isn’t a failover design.
After changing an outbound, retest both explicit and default routing: send one request that matches a rule pointing to the new tag, and another that matches no rules. This can reveal either of two problems: “the first outbound changed, but old rules still point to the previous one” or “the rule changed, unintentionally affecting the default outbound.” Start a fresh test connection after switching outbounds; a browser connection pool may keep existing sessions on the previous path.
routing Routing Rules
First Match and Combining Conditions
routing.rules is an ordered list. The core checks requests against rules from top to bottom and sends a match to the outbound specified by that rule. It doesn’t collect every possible match and choose the most specific one. A rule that matches all web requests by inbound tag can override domain exceptions below it if placed first. Put higher-priority conditions earlier, and test the default outbound with a request that truly matches no rule.
For common field-based rules, different conditions in the same rule must all match, while multiple candidates in a single field list usually mean any one of them can match. Putting both an inbound tag and a domain in one rule means traffic must come from that inbound and match the domain condition. To mean “any of these inbounds, or any of these domains,” write two separate rules. Combining adjacent rules may reduce the line count but can turn an OR into an AND.
This snippet works with the dual-outbound config on this page. It blocks only requests from local-socks to the reserved example domain. domain: matches the name at a domain boundary and its subdomains. To match only one exact hostname, use full:. The domain field takes a hostname condition, not a full URL with a scheme, path, and query string; routing doesn’t compare the entire address-bar URL.
{
"routing": {
"domainStrategy": "AsIs",
"rules": [
{
"type": "field",
"inboundTag": ["local-socks"],
"domain": ["domain:blocked.example"],
"outboundTag": "deny"
}
]
}
}
Use the reserved domain to check the routing input, then look in the logs for a match to deny. This example domain isn’t for normal browsing, so a failed connection alone doesn’t prove the blocking rule worked. For comparison, send requests to the same domain through the SOCKS inbound and the configured HTTP inbound. The first should select the blocking outbound; the second should use the default direct outbound. Even if neither request gets a webpage response, the selected outbounds should differ.
Domain Strategy and Rule Resources
AsIs matches against the target as received; it doesn’t look up an IP just to turn a domain into an address. IPIfNonMatch lets a domain target be resolved after the initial match fails, then tries applicable IP rules. An earlier matching domain or broad rule may prevent this extra check. IPOnDemand allows resolution to be triggered when needed during matching. These strategies change when the routing stage needs an address; they don’t set the system-wide DNS strategy.
geosite: refers to categorized domain entries; geoip: refers to categorized IP entries. The available categories and their locations depend on the resource files in the runtime environment. Category names aren’t a fixed set of strings built into the core. If startup logs report missing resources or entries, first confirm which data set the core loaded, then test with a single known domain or network range. Don’t broadly loosen rules to work around missing data; that can turn a resource-loading problem into hard-to-spot false matches.
When testing IP-based rules, first confirm the target type. If the client sends an IP, a domain-category rule has no domain to match. If it sends a domain, don’t expect routing with AsIs to resolve it automatically and match an IP category. The built-in resolver may return multiple addresses, possibly from different address families. Record whether the input is a domain, IPv4, or IPv6, and change only one input condition at a time.
Check Matching and Non-Matching Paths
For each important rule, record one request that should match and one that differs by just a single condition. To troubleshoot an unexpected match, check the target, inbound source, and actual outbound, then find any earlier candidate rule in the list. Temporarily moving a rule earlier can help with comparison, but review the other exceptions before making the change permanent—especially requests protected by narrower conditions. A single rule move can send multiple groups of traffic down a different path.
Routing can’t fix a connection problem with the selected outbound. If the logs show the expected outbound, investigate that outbound’s address resolution, connection attempt, or handshake—even if the request fails. Continue changing match conditions only if the selected tag is unexpected. The client’s global or rule mode is another layer of selection. See the proxy mode guide to confirm the active mode is loading the rule set you’re checking.
dns DNS Resolution
Where Resolution Happens
A domain may be resolved by the application, the device running the core, or the remote outbound. If the application looks up the address first, the inbound may receive only an IP. If the application passes the hostname to the core, routing can check the domain first. If the outbound passes the target name to a remote server, that server may resolve it when establishing the target connection. When results differ, don’t assume a particular resolver returned a bad answer. First identify which connection stage looked up which name.
The remote node’s address and the website’s address are two different DNS lookups. The core must resolve the remote address before it can dial. Only after the remote connection is ready might the remote server handle the target name. If the logs show a failed lookup for the node’s domain, changing rules for the target website won’t fix the node connection. Conversely, successfully connecting to the remote proves only that the node address is reachable; it doesn’t prove the remote can resolve and connect to the requested target.
The dns section here configures the core’s own resolver. It doesn’t replace the system resolver or automatically intercept every DNS query from browsers, other applications, or a virtual network interface. If an application uses its own DNS, neither system nor core settings may be involved in its initial lookup. For comparison, keep the inbound, target, and outbound unchanged and change only where resolution occurs. This avoids conflating DNS and routing changes.
Static Mappings, System Resolvers, and Query Triggers
This example adds a static mapping for a test hostname to built-in DNS resolution. Other names that need lookups can go to localhost, which uses the runtime environment’s local system resolver. The example address is in a documentation-only range, not on a server providing a service. Use it to observe which address the domain maps to, not to check whether a webpage opens. Remove the test record afterward; don’t leave it in your everyday config.
{
"dns": {
"hosts": {
"reference.test": "192.0.2.10"
},
"servers": ["localhost"]
}
}
Adding just the section above doesn’t mean every request to reference.test will use built-in resolution. To observe routing using it, create a separate test config with IPIfNonMatch, make sure no earlier broad rule matches, and add an IP rule for 192.0.2.10/32 that points to deny. Send a request for the reserved domain with the hostname passed through the proxy, then check the logs to see if the IP rule matches. This test observes the routing decision; it doesn’t require a connection to the example address.
If routing resolves a name to check an IP condition, that doesn’t prove the outbound will dial using the same address. The outbound may preserve the hostname or resolve it again according to its own address strategy. When investigating inconsistent DNS results, record “why the route matched” separately from “where the final connection went.” If the two stages used different addresses, check each stage’s input and resolver rather than treating the IP in the matching condition as the final connection address.
Address Families, Caching, and DNS Dependencies
If a lookup returns an address but the connection still fails, check whether it’s IPv4, IPv6, or both, then verify reachability over the relevant network. Having no usable IPv6 route isn’t the same as receiving no IPv6 record. When comparing address families, keep the target and outbound the same; a successful connection to a different site doesn’t prove there’s a problem with the original. Before restricting a strategy to one address family, confirm whether it affects matching, resolution, or dialing.
After changing DNS settings, the application, system, and core may each retain results, and existing connections may keep using old addresses. Start a new connection before retesting; clear caches only in the relevant component if needed. Don’t flush everything and change several strategies at once. For a custom resolver specified by domain name, also check how it gets its initial address and whether its queries depend on a remote outbound that can’t yet connect. Increasing the query timeout won’t resolve a circular dependency that prevents startup.
Distinguish between no records, a refused query, a query timeout, and a connection timeout after resolution. The first three call for checking the query target and resolver reachability; the last calls for investigating the actual connection path. A system lookup on the device can provide a comparison, but it doesn’t replace the core’s access logs. Tracking which stage sees only a hostname and which already has an address usually narrows the problem to a specific handoff.
policy Session Policies
User Levels and Scope
policy.levels groups session parameters by user level. Object keys are strings, such as "0", while the corresponding level in a protocol is usually an integer. Sessions generally use level zero unless another level is specified; the exact behavior depends on the protocol and core implementation. A level is just a parameter index: a higher number doesn’t mean higher permissions, priority, or speed. Before configuring multiple levels, check which object in the protocol reads the value.
Routing selects the outbound; session policies control how applicable sessions wait at specific stages. inboundTag and user level are separate mechanisms: the former identifies a listener and can be used in rule matching; the latter selects session parameters. To use different timeouts for different inbounds, confirm that the inbound protocol lets you set the relevant session level. Changing only the inbound tag, or referring to a level name in routing, won’t create that association.
{
"policy": {
"levels": {
"0": {
"handshake": 8,
"connIdle": 180,
"uplinkOnly": 5,
"downlinkOnly": 10
}
}
}
}
These values are demonstration settings in seconds, not defaults or general recommendations. handshake limits the protocol-handshake stage for applicable inbounds; it isn’t a total timeout for the entire request. If an application can’t reach the listener, changing it won’t fix an unreachable port. If the remote reports a security handshake error, don’t assume this setting caused it. First check whether the log reports an inbound protocol handshake, a remote connection attempt, or a remote handshake, then inspect the relevant parameters.
Idle Timeouts and Half-Closed Connections
connIdle sets how long a connection can remain idle. A long request with data flowing throughout isn’t the same as a long period with no activity. An application that sends data intermittently may legitimately be silent for a while. If a long-lived connection always drops after roughly the same idle interval, keep the outbound and application fixed, record the time from the last successful transfer to the disconnect, then adjust one setting and retest. Don’t blame every short-connection failure on the idle timeout.
uplinkOnly and downlinkOnly control how long a session waits after only one direction of traffic remains; they aren’t upload or download speed limits. When the downlink has ended but the uplink remains, check the former; when the uplink has ended but the downlink remains, check the latter. Some applications send a request and then stop uploading while waiting for the response. A short half-close window may expose problems that a basic webpage test won’t. To reproduce a disconnect, keep the request body and response behavior the same.
A connection can also be closed by the application, server, or an intermediary device. If the interruption time doesn’t change after you adjust the core’s idle setting, investigate the other participants instead of increasing the timeout repeatedly. Test handshake failures, idle disconnects, and half-close disconnects separately. For comparable results, keep the target, transport, outbound, application version, and inbound mode as consistent as possible.
Statistics and How to Monitor Them
Statistics and timeouts share a policy section, but work independently. Statistics typically require enabling the top-level stats module, then enabling the counters you need under the relevant policy. For example, policy.system.statsInboundUplink can enable inbound upload statistics. Per-user counts also depend on the user-level settings and whether the protocol supplies a user identifier. Setting an option with a similar name doesn’t guarantee that statistics will appear on every page of the client.
Counters need to be read by a component that supports statistics. They don’t automatically produce a usage report and aren’t a latency or reachability test. If the client already has a statistics interface, first check the counters it exposes. Don’t add a management listener just to inspect logs. If a counter stays at zero, check in order whether the module is enabled, whether the object has the relevant tag or identifier, whether the reading belongs to the current process, and whether the test request actually passed through that object.
Before tuning policies, keep an unmodified baseline and a request you can replay. Record the start time, last activity, and reason for disconnection—not just whether the webpage opened. After the client regenerates the file, confirm the setting is still present in the loaded config. If the running config doesn’t contain the policy, the test can’t tell you whether the value is effective. Keep the setting only if you can reproduce a consistent change.
Configuration Validation and Troubleshooting
From File Checks to Proxy Requests
Validate in three stages: the file parses, the process starts successfully, and the actual request follows the expected path. Passing one stage doesn’t prove the next. When checking a file, confirm the path used by the startup command. If you restart through the interface, also confirm the config source and active core. Especially when you have both a test directory and a client working directory, seeing a file named config.json doesn’t prove the running process loaded the file you just saved.
When running a core manually, choose the config-check command below for the core type. Run it from the config’s directory or change the file argument to its actual path. If the launcher uses different command-line arguments, check the help output from your local core. A successful config check means the core accepts the input; it doesn’t guarantee the listener can bind or that a remote will be reachable after startup. Once the check passes, start the process and review its startup logs.
xray run -test -config config.json
v2ray test -c config.json
Start with the minimal config from the structure overview, then use a SOCKS5-capable application to send an explicit proxy request. The command below works in environments with curl installed. socks5h sends the target hostname through the proxy. It doesn’t guarantee that built-in DNS performs the lookup; it only confirms the test tool didn’t resolve the hostname to an IP before submitting it. The external target may be unreachable, so you can use a test site you’re authorized to access and know is reachable directly.
curl --verbose --max-time 12 --noproxy "" --proxy socks5h://127.0.0.1:10808 https://example.com/
You don’t need to enable the system proxy or virtual network interface at the same time for the initial test. An explicit proxy request isolates whether the application follows system settings. First verify a complete round trip through the direct outbound, then add a blocking outbound and routing rules and check whether the selected tag changes. Connect a known-working remote only after that. If the basic path already fails, adding routing resources, DNS strategies, or multiple nodes will only broaden the troubleshooting scope.
Find the First Failing Handoff
| Symptom | Check first | Test |
|---|---|---|
| Config validation error | JSON structure, field values, routing resources | Start with the first error. Restore a working baseline, then add sections one at a time. |
| Inbound connection fails | Running instance, bind address, and port | Temporarily keep just one listener and test with an explicit application proxy. |
| Wrong outbound selected | Request target, inbound tag, and rule order | Send fresh requests that should and shouldn’t match. |
| Correct outbound, but connection fails | Resolution, dialing, transport, and handshake | Use the same inbound to compare direct connections with a specific remote, and check where the failure occurs. |
| Disconnects after running for a while | Last activity time and direction of closure | Keep the application and connection path fixed; test idle timeout and half-close behavior separately. |
When reviewing logs, collect consecutive entries covering the time range of a single request. Startup warnings may be unrelated, and later retries can obscure the first useful clue. Find the first failure related to the request, then check whether the inbound and outbound were confirmed before it. Raise the log level temporarily only as much as needed to observe the relevant stage, then restore it to avoid retaining more destination and runtime details than necessary.
A “running” status in the interface means only that the client believes the process started; it doesn’t prove the application reached the right inbound. If the logs show no test request, check the protocol and address entered in the application, then whether it’s using only the system’s default path. If a request appears in the logs but uses the wrong outbound, recheck the active config and rule order. If the logs show a remote handshake error, first check that the outbound matches the server—don’t rush to replace the entire routing setup.
Minimal Reproduction and Rollback
To roll back, restore the last known-good file and restart the corresponding instance. Send a new request using the same proxy port and target. Once the baseline works, add one change at a time and record the expected tag and actual result at every step. If the baseline also fails, check for environmental changes first: whether the process is still running, whether a new application took the port, whether system routes changed, and whether the original target is still reachable. Don’t keep piling on unverified changes at this stage.
When asking for help, provide the operating system, client and core names, the stage where the issue occurs, a minimal config, and a log excerpt for the same request. Remove subscription URLs, identity fields, internal domains, and unrelated connection records, but keep the error type and relationships between fields. To search by error text, see how to diagnose runtime logs. If the issue occurs during subscription import or a system proxy switch, check the Frequently Asked Questions as well. Confirm the client-level behavior before investigating core fields.