Release 9 for Fast GIS

Release 9

Some Templates

  • Absolute Value
  • Areas
  • Arithmetic Functions
  • Aspect
  • Logarithms
  • Bessel Functions
  • Between
  • Binary Functions
  • Blur
  • Boolean Functions
  • Bounds
  • Branch
  • Buffer
  • Ceilings
  • Center Functions
  • Compare Order
  • Complementary Error Function
  • Compose Circle
  • Compose GML
  • Compose GeoJSON
  • Compose Point with Z
  • Compose Point
  • Compose Rectangle
  • Compose Segment
  • Compose Triangle
  • Compose WKT
  • Concatenate
  • Convert to Area
  • Convert to Line
  • Convert to Point
  • Convex Hull
  • Date Functions
  • Decompose to Branches
  • Decompose to Coordinates
  • Decompose to Segments
  • Direction Blur
  • Direction Edges
  • Distance
  • Edges
  • Enclosing Box
  • Error Function
  • Escape, JSON
  • Exponent
  • Floors
  • Fractional Parts
  • Gamma Function
  • Gaussian Blur
  • Geoms with Curves
  • Geoms with Z
  • Hyperbolic Trig
  • Hypotenuse
  • Is NULL
  • Is not NULL
  • JSON Array
  • JSON Boolean
  • JSON Number
  • JSON Object
  • JSON String
  • Length
  • Like
  • Linearize
  • Log-gamma Function
  • Lower Case
  • Merge Areas
  • Merge Lines
  • Merge Points
  • Modulo
  • Multiply
  • Negate
  • Noise
  • Normalize Topology
  • Normalize
  • Number of Branches
  • Number of Characters
  • Number of Coordinates
  • Number of Regexp Matches
  • Orthogonalize
  • Pad Functions
  • Parse GML Coordinate System
  • Parse GML
  • Parse GeoJSON Coordinate System
  • Parse GeoJSON
  • Parse WKB
  • Parse WKT
  • Points
  • Power Functions
  • Reciprocal Cube Root
  • Reciprocal Square Root
  • Regexp Match
  • Remove Curves
  • Remove Z
  • Replace Regexp
  • Reverse Text
  • Rotate
  • Round
  • Scale
  • Segmentize
  • Set Z
  • Sharpen
  • Shift
  • <
  • Slope
  • Smooth
  • Subtract
  • Tangent
  • Text Contains
  • Text Cut
  • Text Ends with
  • Text Matches Regexp
  • Text Position, Nth
  • Text Position
  • Text Sounds like
  • Text Starts with
  • Text at End
  • Text at Start
  • Title Case
  • Translate Characters
  • Trigonometry
  • Trim
  • Truncate
  • Unescape JSON
  • Union Areas
  • Union Boxes
  • Upper Case
  • Vector Value
  • Voronoi Diagram
  • and many more...

Spatial SQL

Accomplish Miracles - Automatically!

GIS is about Spatial Data

Data that powers decisions, wealth creation and success in today's world is not your grandfather's data: today you need seamless capability to manage and understand data in the context of location - spatial data.

Classic database engines are great for traditional data but they lack features and architecture required by today's spatial data. Classic GIS, built without an integrated spatial data engine inside, cannot match the power, convenience, and performance of newer technology designed to master spatial data demands.

Manifold® Release 9 is built upon Manifold's massively parallel Radian® spatial database platform, by far the world's richest, fastest and most powerful spatial data engineering engine built for GIS.

Manifold Release 9 is only $145, fully paid. The world's most advanced spatial SQL is only $145. Amazing! That's the fully paid price for Manifold System Release 9. The fastest and most powerful GIS ever created now also has the world's lowest cost of ownership.

Doing data science or other serious work with spatial data? See the SQL: Manifold vs. Arc page for why Manifold's superb spatial SQL is a better choice than Esri's subset of SQL.

Why does this page have a photo of Sainte Chapelle? Because Sainte Chapelle is perfect, the highest and best implementation of Gothic aspirations in architecture. Manifold SQL is like that too - not perfect like Sainte Chapelle, but for spatial work head and shoulders above all else and devoted to honoring the mighty idea that is SQL. Try it and see if you agree.

New !   Get Real SQL in ArcGIS Pro

SQL for ArcGIS Pro

New ! Esri users can now enjoy the world's best spatial SQL as an add-in to Esri's flagship desktop GIS package. Launch the full power of Manifold SQL from ArcGIS® Pro.

SQL for ArcGIS Pro is a new add-in for Esri's ArcGIS Pro desktop GIS. The add-in provides spatial SQL for Esri file geodatabases in your ArcGIS Pro project in tight integration with ArcGIS Pro.

The add-in enhances ArcGIS Pro with the world's most powerful desktop spatial SQL engine, Manifold's Radian® engine, to unleash the phenomenal power of SQL from your ArcGIS Pro desktop. Enjoy full-featured SQL, superior quality, and the amazing speed of parallel CPU and parallel GPU query execution, all supported with hundreds of SQL functions for every spatial need.

In Advanced mode the add-in runs spatial SQL with hundreds of file formats, databases, web servers, and other data sources outside of ArcGIS Pro. Ultrafast data storage in the add-in makes it easy to combine huge data from outside your ArcGIS Pro project with data inside the project.

When you read about the many advantages of real SQL in web pages like this, keep in mind that you can upgrade ArcGIS Pro to have real SQL as well by installing Manifold's SQL for ArcGIS Pro add-in.

Special introductory offer: Save $100 off the regular price of $245 - Only 145.   Visit the website for complete information.

Manifold SQL Advantages

Unlike other desktop GIS packages, which have no built-in SQL, Manifold is built from the ground up as one of the world's most modern and fastest SQL machines. That provides many advantages and exceptional spatial SQL expertise. More than just a well-implemented SQL, Manifold's SQL engine includes multiple hardcore features specifically designed for spatial SQL in real life use with emphasis on performance and control: constraints, computed fields, spatial and non-spatial indexes, temporary tables and temporary databases, precisely controlled multi-threaded execution, offloading of advanced raster operations to GPGPU, read-only and transparent read-write caches, and much more.

It's a Database World

Far more than just a client, the Manifold engine provides a powerful database and SQL query engine built for large, complex operations characteristic of spatial data and spatial data engineering. The Manifold SQL query engine and database were created from the ground up for automatic, massive parallelism in everything. Manifold's raw speed and massively parallel performance enable you to accomplish spatial engineering magic on the desktop in seconds or minutes, and not hours or days, with today's spatial data. That same, raw speed lets Manifold keep up with Enterprise data servers as a client for more effective use of your organization's data. Power like that cannot be glued onto legacy software: it must be designed in and built as an integrated system from the very first line of code.

"That EXECUTE [[....]] statement still has me smiling. I now find myself mixing and matching SQL Server, PostGIS, SpatiaLite, and Manifold on a daily basis. I think knowing how to integrate SQL Server with Radian is a killer skill in the Microsoft ecosystem. " - Forum post

Our Kind of Data

The Radian database engine was designed from the ground up to handle spatial data in all the forms you will need: vector data, raster data, curvilinear objects, Z data, multichannel data and any pixel type. Specialized infrastructure, like an exceptionally rich selection of dedicated indexes, guarantees the fastest possible pipeline between parallel data access and massively parallel algorithms. Manifold's SQL query engine optimizes automatically for the special needs of spatial data types and parallel algorithms. It's all under the hood so when you step on the gas the system roars. Point it where you want to go and Manifold does the rest.

Be Friends with Everybody

The world's spatial data - your spatial data - hangs out in a host of database servers, file databases, web server sources and file formats. Manifold connects to them all. Better still Manifold connects to and works with multiple sources. Transfer and blend data from multiple sources at once. Write SQL in Manifold to move data directly from PostgreSQL into SQLite:

SELECT * INTO [sqlite_connection]::[roadtable]
FROM [postgres_connection]::[public.roads]
"Because I can use a command window to write native queries Radian is effectively a client for Postgresql, or indeed any other DBMS - I no longer need to rely on PGAdmin." - Forum post

Everything is Exposed

Manifold exposes all aspects of data manipulation to the database. All metadata and properties, all tiles and geometry, every pixel and every coordinate system, every attribute, every property, every bit of metadata, all of it is at your fingertips to manipulate with SQL or with dialogs. Extensive functions for coordinate systems and other infrastructure make it easy to hammer vast quantities of data into exactly the form you desire, with surgical precision. Complex formatting applied to one image that you want in another? Easy - copy and paste the style value from one to the other in the metadata table. Use a dialog, cobble up some SQL or call a script to do that for thousands of images at once. Everything is possible.

Everything is Parallel

Superior spatial database engineering requires parallel power, and parallelism cannot be glued on to non-parallel code. It has to be built-in from the ground up. Manifold was created from the ground up as an always-on, fundamentally parallel system. The Radian database engine is a parallel engine and Manifold SQL automatically runs parallel

Whenever it makes sense to do so, Manifold will automatically utilize multiple processors or multiple processor cores by parallelizing a task into multiple threads for execution on more than one core. Given hyperthreading plus multi-core CPUs it is now routine to encounter desktop systems with 8, 16, 32 or even more CPU cores available. See the Parallel CPU page for info on CPU parallelism in Manifold.

In addition to this basic, parallel processing capability using multiple CPU cores Manifold also includes the ability to utilize massively parallel multiprocessing utilizing GPUs, potentially launching tasks on thousands of processing cores at once for true supercomputer computational performance, far beyond what can be achieved with CPUs.

Manifold automatically parallelizes and dispatches as many tasks as make sense to GPGPU, with automatic fallback to parallelized tasks dispatched to multiple CPU cores if a GPU is not available. CPU parallelism in Manifold is also a key part of providing massively parallel GPGPU function, because many CPU cores working in parallel are required to ensure maximum use of GPU. A single CPU core running non-parallel is not fast enough to keep up.

Supercomputer Speed with GPU

GPU acceleration works everywhere in Manifold SQL where worthwhile work arises: in the SELECT list, in WHERE, in EXECUTE, ...everywhere. For example, if you add to a table a computed field that combines multiple tiles together, that computed field will use GPGPU. If you do some tile math in a FUNCTION, that FUNCTION will use GPGPU as well.

You don't have to write something special or learn programming environments like CUDA. Use the same SQL you already know and Manifold automatically parallelizes it to use GPGPU. If you don't use SQL but prefer point-and-click Manifold templates, those automatically use GPGPU as well.

When you write something like SELECT tilea + tileb ∗ 5 + tilec ∗ 8 FROM ..., the Manifold engine takes the expression with three additions and two multiplications, generates GPGPU code for that function in a Just In Time, JIT manner and uploads the resulting code to GPGPU to execute the computations.

To save execution time and boost efficiency, JIT code generation for GPGPU functions is cache-friendly for the driver. Running the same query again, or even running different queries for which the GPGPU expressions are sufficiently similar to each other, will engage the compilation cache maintained by the driver. Saving snippets of SQL to define computed fields or new functions saves the GPU code as well.

If you save the project using that computed field or function into a Manifold .map project file and then open that .map file on a machine running Manifold that has no GPGPU, the computed field will be executed by Manifold automatically falling back to using Manifold's CPU parallelism, taking advantage of as many CPU cores are available using CPU core parallelism instead of GPGPU. If you launch that .map file on a machine that has a GPGPU, Manifold will automatically use the GPGPU.

Other optimizations play along transparently. If a particular subexpression inside of an expression that runs on GPGPU is a constant in the context of that expression, it will only be evaluated once. If an expression that can run on GPGPU refers to data from multiple tables and has parts that only reference one of these tables, the join optimizer will split the GPGPU expression into pieces according to dependencies and will run these pieces separately and at different times, minimizing work. A SELECT with more than one thread will run multiple copies of GPGPU expressions simultaneously. There are many other similar optimizations automatically integrated with GPGPU utilization.

Some operations are so trivial in terms of computational requirements it makes no sense to dispatch them to GPGPU, the classic case being scalars (trivial) as opposed to tiles (more bulk). CASE expressions, conditionals and similar constructions or functions that operate on scalar values stay on the CPU while functions that operate on tile values generally go to GPGPU unless they use tiles in a trivial fashion, such as making a simple comparison.

Manifold's automatic CPU parallelism with typical multicore CPUs is so fast that keeping lighter operations on parallel CPU is faster than packaging them for dispatch to GPU. Each processor core in a modern CPUs is a very powerful computing machine: When Manifold parallelizes a task to sixteen or twenty four CPU hypercores, that is a massive amount of computing power. Manifold automatically adapts to however many CPU cores are in the computer: even inexpensive Threadrippers provide 48 threads, and Manifold can exploit every one of them to surge through even the most demanding jobs.


  • Abs(v) takes a number and returns a number: it stays on CPU.
  • TileAbs(t) takes a tile and returns a tile: it can go to GPGPU.
  • TileContrast(t, c, p) takes a tile and two numbers, and returns a tile: it can go to GPGPU.
  • TileToValues stays on CPU since it is simply splitting pixels out of a tile with no need for GPGPU for something so simple. If the operation was doing a computation on the pixels first and then splitting it might then be sent to GPGPU.

CASE conditions are scalar, so they stay on CPU. When CASE is used with tiles whether it is faster to dispatch the task to GPGPU depends on exactly how the tiles are used. Some examples where vXX are scalar values and tXX are tiles:


In the above not much is being done with the tiles so the entire construction stays on CPU.

CASE v WHEN 3 THEN TileAbs(t1)+ t2*t3 + TileSqrt(t4) ELSE t1 END

In the above, the expression in THEN will go to GPGPU while the rest of CASE will stay on CPU.


In the above the comparison in WHEN does use tiles but it uses them like raw binary values, similar to how ORDER works, so it is more efficient to leave it on CPU.

GPU card

How Fast Is Manifold GPGPU?

If you are doing computations it's fast. Really fast. Gains are usually from 20 times faster to 100 times faster than running typical computations on CPU alone, even when using very inexpensive GPU cards. Running complex computations on faster cards, performance can be 100 to 200 times faster than using CPU alone. It's fairly common to do in a second or two what takes more than five minutes without Manifold.

If your time is worth more than minimum wage and you're doing anything that requires your machine to think at a higher level than your coffee pot timer, you'll often pay back the cost of a Manifold license the first time you use it for anything serious. It's that fast.

Pluggable Scripts

Mix and match scripts with SQL to achieve any task: Manifold includes built-in Javascript, C#, JScript, JScript.NET, VB.NET and VBScript plus automatic support for IronPython, IronRuby, F#, PerlScript and PythonScript when installed. Write a function in C# and call it from SQL. Launch a query within a Python script. Scripts can use SQL query functions as if they were implemented in the object model. Use whatever is easiest and works for you.

virtuoso Spatial Functions

Whatever your tool does not provide you get to write yourself. Manifold provides every tool you need to blend, transform, analyze and manipulate the world's most complex spatial data in a flash. Manifold's sophisticated parallelized spatial operators, like topology and spatial overlays, work with mixed objects, pathological geometry and do not require special data cleaning or simplification before use. Hundreds of specialized Manifold functions are waiting for you patiently on the shelf, tucked unobtrusively out of the way but bristling with power, ready to work for you when your SQL calls them into play.

Our Place or Yours?

Execute queries that mix and match Manifold functions and SQL with what an external query engine can do: Use Manifold within Oracle or vice versa. Manifold slices queries for dispatch where you want.

"Yes, I shall take credit as being the first living human to ever do this (I feel just like Neil Armstrong, or Rosa Parks). OK, that's a bit of stretch :-) But, think about what we are doing: 1. I've written a SQLite/spatiaLite query (it could have easily been PostGIS, Oracle, SQLServer) [...] 2. I am selecting the result of the SQLite query and combining it with a Manifold spatial function. 3. The result is being selected back into a SQLite table. This is an excellent example of how Manifold really can be a Rosetta Stone to all the different packages out there, in a truly unique way. What other product can pull this off ?" - Forum post

Location, Location, Location

Automatic support for over 6500 different coordinate systems and over 1500 coordinate system transformations, including all of EPSG and numerous other spatial reference systems. SQL and Template functions provide full convertability between GeoJSON, WKB, WKT, GML and other systems as well as extensive support for parallelized coordinate system transformations for rasters and vectors.

Perfect Precision

Exceptionally high precision coordinate system and base coordinate system transformations including all standard high precision routines used worldwide.

Manifold Writes SQL For You

You know those "Hello, World" moments when you really would like to see how it's done in a new system, to learn how to cut through infrastructure and do what you want? Manifold makes that easy for you by automatically writing SQL to show you how it's done.

Want to see how a point-and-click template works? Click the Edit Query button and Manifold launches a command window loaded with the SQL the template executes so you can see what functions are being used. It's a live query, so you can customize the SQL as you like or copy and paste into new queries.

Select and Transform in a Neolithic Relics Database. See Manifold technology in action Watch the Select and Transform in a Neolithic Relics Database YouTube video of Manifold Viewer enabling interactive selection and transformation using point and click dialogs, to help find Neolithic relics in France. The video also shows how Manifold can automatically write SQL for you.

SQL Everywhere

You can use snippets of SQL everywhere in Manifold. When a point-and-click combo box allows you to pick a field you can write an SQL expression into that combo box to customize what the dialog does.

Maybe we want to copy a value into a field from a Date field but instead of copying the Date we want to copy the day of the month, but as a text value. No problem - we write CAST(DateTimeDay([Date]) AS NVARCHAR) into the combo box instead of simply choosing the Date field. We not only get the day of the month, we also CAST it into text form.

Manifold Commander

New! Automate Complex Jobs with Manifold® Commander

New ! Manifold® Commander is a console application version of Manifold that provides the full range of Manifold query and scripting capabilities from a command line, making it easy to automate tasks.

Commander launches from a command line such as in a Windows Command Prompt window, or in a .bat batch file, or from a Windows PowerShell script, from within Windows Task Manager to automate tasks.  Commander can run either SQL queries or scripts from within a specified .map file, and Commander also can run scripts from a specified script file stored outside a Manifold project. Script in ten different languages!

    Automate complex jobs using SQL
  • Your own Automated Factory - Commander provide an automated production line for accomplishing nearly any GIS, DBMS or ETL task. String together any of hundreds of functions using whatever logic you want in a sequence of SQL queries, or use scripts in any of ten different programming languages. Manifold features like the Transform pane will automatically write SQL that accomplishes what you've set up using point and click templates. It's like being able to tell a factory full of robots what you want them to do.
  • Built into Universal and Server Editions - Manifold Release 9 Universal and Server licenses include Manifold Commander. Installing either Release 9 Universal or Release 9 Server automatically installs Manifold Commander. When you buy Release 9 Universal for $195 you automatically get Manifold Commander as well. There is no need to make any additional purchases to get Commander.
  • Replace Costly and Slow ETL Tools - Commander is Manifold, so just like Manifold it runs fully parallel, with incredible parallel CPU and massively parallel GPU speed. Queries and scripts provide access to the full power of Manifold, enabling use of hundreds of Manifold functions and the full power of SQL and scripts to interact with data in databases or in any of hundreds of formats and data sources, to transform that data, do analyses, and save the transformed data or results or output to desired formats. Replace costly, non-parallel tools like FME at a fraction of the price.
  • Schedule Tasks - Using Windows Task Scheduler you can launch tasks using Commander on a regular schedule, such as updating a CSV every night for serving to clients, updating databases, or converting files into different formats.

See the Manifold Commander user manual topic for details and illustrated, step by step examples.

Experience Manifold Power in a Free Tool

Manifold Viewer is completely free - no need to register, no ads, no upsell, no soliciting donations - it's really free!

Manifold Viewer is the free, read-only version of Manifold Release 9. Although Viewer cannot write projects or save edited data back out to the original data sources, Viewer provides phenomenal capability to view and to analyze almost all possible different types of data in tables, vector geometry, raster data, drawings, maps and images from thousands of different sources. Viewer includes full SQL as well, with hundreds of spatial and other analytic functions.

Viewer can also create and write spatial indices for entire folders full of LiDAR files, save connections to favorite files and data sources, and even edit and save localization files to translate Manifold into new languages.

Manifold Viewer delivers a truly useful, fully CPU-parallel and GPU-parallel Manifold tool that gives you parallel power and endless Manifold capabilities at zero cost. No need to register, no adware, no requests for donations and no selling: use Viewer however you like, including commercial purposes. You can even redistribute Viewer, all for free.

Viewer is a great way to share the amazing projects you create in Manifold for free. Publish multi-hundred GB projects created in Manifold that anybody can pop open in 1/10th second for free using Viewer. Publish projects that include automatic connections to your organization's databases and worldwide webserved data, and include pre-built, sophisticated analytics and dynamic reporting that users can launch with a point and click. Track pandemics, help first responders fight wildfires, or just help your organization do a better job.

See Manifold Viewer in Action.

Viewer's small download (only 50 MB), instant launch, and clean display - free of convoluted ribbons and endless, confusing buttons - make it perfect for unskilled users. With Viewer a million people can share the dazzling analytics and insights you create with an inexpensive Manifold license, all at fully parallel speed with no need to pay for costly, cloud-based, web processing. Like Manifold, Viewer never crashes, no matter how big or complicated the job.

See Viewer in action Watch the Manifold Viewer Introduction YouTube video.

"Mfd 9 is becoming a really good tool for sharing data with non-GIS folks. Clean interface makes it easy to teach others simple tasks. Easy to transfer a project. Easy to install software. Free viewer." - Forum post

Get Manifold Viewer

Buy Now via the Online Store

Buy Manifold products on the Online Store. The store is open 24 hours / seven days a week / every day of the year. Orders are processed immediately with serial number email sent out in seconds. Use Manifold products today!

 Click to begin shopping

A Sample List

Tired of "spatial" SQL products that provide a handful of functions? That's not Manifold. Manifold has you covered for every possible need with a vast selection of SQL statements, operators and functions. Manifold's spatial experts with decades of experience in spatial engineering have provided everything that everyone from a novice to maximum expert will want, all neatly organized within the query builder with easy filtration to find just the right function for a task. Following is a sample list of some, but not all, of what you get in SQL with Manifold.

  • ADD
  • DROP
  • INTO
  • MOD
  • DIV
  • LIKE
  • IN
  • NOT
  • AND
  • OR
  • XOR
  • CAST
  • CASE
  • Avg
  • Corr
  • Count
  • Covar
  • CovarPop
  • First
  • GeomMergeAreas
  • GeomMergeLines
  • GeomMergePoints
  • GeomUnionAreas
  • GeomUnionBoxes
  • JoinAnd
  • JoinBitAnd
  • JoinBitOr
  • JoinBitXor
  • JoinOr
  • JoinXor
  • Last
  • Max
  • Median
  • Min
  • StDev
  • StDevPop
  • StringJoinTokens
  • Sum
  • Var
  • VarPop
  • Abs
  • Acos
  • Acosh
  • Asin
  • Asinh
  • Atan
  • Atan2
  • Atanh
  • BinaryWkbGeom
  • Cbrt
  • Ceil
  • CeilDecs
  • Chr
  • Coalesce
  • Collate
  • Compare
  • ComponentCoordSystem
  • ComponentName
  • ComponentPath
  • ComponentProperty
  • ComponentType
  • CoordConvert
  • CoordConvertPoint
  • CoordConvertPoint3
  • CoordConvertTile
  • CoordConvertTrace
  • CoordConverterIsIdentity
  • CoordConverterIsScaleShift
  • CoordConverterIsXYZ
  • CoordConverterMake
  • CoordConverterSteps
  • CoordDatum
  • CoordDatumDefault
  • CoordDatumEpsg
  • CoordDatumParameters
  • CoordDatums
  • CoordSystem
  • CoordSystemDefault
  • CoordSystemDefaultLatLon
  • CoordSystemEpsg
  • CoordSystemOverride
  • CoordSystemParse
  • CoordSystemParseEpsg
  • CoordSystemParseOverrides
  • CoordSystemParseSrid
  • CoordSystemParseSridSubtype
  • CoordSystems
  • CoordSystemTypeParameters
  • CoordSystemTypes
  • CoordTransform
  • CoordTransformEpsg
  • CoordTransforms
  • CoordTransformTypeParameters
  • CoordTransformTypes
  • CoordUnit
  • CoordUnitByName
  • CoordUnitDefault
  • CoordUnitDefaultLatLon
  • CoordUnitEpsg
  • CoordUnits
  • Cos
  • Cosh
  • DataLength
  • DateTimeDay
  • DateTimeHour
  • DateTimeMillisecond
  • DateTimeMinute
  • DateTimeMonth
  • DateTimeSecond
  • DateTimeYear
  • Erf
  • Erfc
  • Exp
  • Exp10
  • Exp2
  • Expm1
  • Floor
  • FloorDecs
  • Fract
  • FractDecs
  • GeocodeAddress
  • GeocodeAddressMatches
  • GeocodeAddressSupported
  • GeocodeLocationMatches
  • GeocodeLocationSupported
  • GeomAdjacent
  • GeomArea
  • GeomBounds
  • GeomBox
  • GeomBranch
  • GeomBranchCount
  • GeomBranchFirst
  • GeomBranchLast
  • GeomBuffer
  • GeomCenter
  • GeomCenterInner
  • GeomCenterWeight
  • GeomClip
  • GeomContains
  • GeomConvertToArea
  • GeomConvertToLine
  • GeomConvertToPoint
  • GeomConvexHull
  • GeomCoordCount
  • GeomCoordXY
  • GeomCoordXYZ
  • GeomDistance
  • GeomDistancePoint
  • GeomDistancePoint3
  • GeomGml
  • GeomHasCurves
  • GeomHasZ
  • GeomIntersects
  • GeomIsArea
  • GeomIsLine
  • GeomIsNormalized
  • GeomIsPoint
  • GeomJsonGeo
  • GeomLength
  • GeomLinearize
  • GeomMakeCircle
  • GeomMakePoint
  • GeomMakePoint3
  • GeomMakeRect
  • GeomMakeRectDiagonal
  • GeomMakeSegment
  • GeomMakeSegment3
  • GeomMakeTriangle
  • GeomMakeTriangle3
  • GeomMergeAreasPair
  • GeomMergeLinesPair
  • GeomMergePointsPair
  • GeomNormalize
  • GeomNormalizeTopology
  • GeomOrtho
  • GeomOverlayAdjacent
  • GeomOverlayContained
  • GeomOverlayContaining
  • GeomOverlayIntersecting
  • GeomOverlayTopologyIdentity
  • GeomOverlayTopologyIntersect
  • GeomOverlayTopologyUnion
  • GeomOverlayTopologyUpdate
  • GeomOverlayTouching
  • GeomRemoveCurves
  • GeomRemoveZ
  • GeomRotate
  • GeomScaleShift
  • GeomScaleShiftZ
  • GeomScaleToSystem
  • GeomScaleToSystemCff
  • GeomScaleToUnits
  • GeomScaleToUnitsCff
  • GeomSegmentize
  • GeomSetZ
  • GeomSmooth
  • GeomToBranches
  • GeomToCoords
  • GeomToSegments
  • GeomToShapes
  • GeomToShapesEsri
  • GeomTouches
  • GeomTriangulate
  • GeomTriangulateLines
  • GeomType
  • GeomUnionAreasPair
  • GeomUnionBoxesPair
  • GeomVoronoi
  • GeomVoronoiLines
  • GeomVoronoiPoints
  • GeomWithin
  • GeomWkb
  • GeomWkt
  • Hypot
  • J0
  • J1
  • Jn
  • Lgamma
  • Log
  • Log10
  • Log1p
  • Log2
  • NullIf
  • PragmaValue
  • Rcbrt
  • Round
  • RoundDecs
  • Rsqrt
  • Selection
  • SelectionForWindow
  • SelectionIsEmpty
  • SelectionIsInverted
  • SelectionKeys
  • Sign
  • Sin
  • Sinh
  • Sqrt
  • StringCompareCollate
  • StringCompareKeyCollate
  • StringContains
  • StringContainsCollate
  • StringEndsWith
  • StringEndsWithCollate
  • StringEscape
  • StringEscapeEncode
  • StringEscapeJson
  • StringFind
  • StringFindCollate
  • StringFindNth
  • StringFindNthCollate
  • StringGmlCoordSystem
  • StringGmlGeom
  • StringJsonArray
  • StringJsonBoolean
  • StringJsonGeoCoordSystem
  • StringJsonGeoGeom
  • StringJsonNumber
  • StringJsonObject
  • StringJsonValue
  • StringLength
  • StringPadEnd
  • StringPadStart
  • StringRegexpCount
  • StringRegexpFind
  • StringRegexpFindNth
  • StringRegexpMatches
  • StringRegexpReplace
  • StringRegexpReplaceNth
  • StringRegexpSubstring
  • StringRegexpSubstringNth
  • StringReplace
  • StringReplaceCollate
  • StringReplaceNth
  • StringReplaceNthCollate
  • StringReverse
  • StringSoundex
  • StringStartsWith
  • StringStartsWithCollate
  • StringSubstring
  • StringSubstringLen
  • StringToCharacters
  • StringToJsonArrayValues
  • StringToJsonObjectValues
  • StringToLowerCase
  • StringToLowerCaseCollate
  • StringToRegexpMatches
  • StringToTitleCase
  • StringToTitleCaseCollate
  • StringToTokens
  • StringToUpperCase
  • StringToUpperCaseCollate
  • StringTranslate
  • StringTrim
  • StringTrimEnd
  • StringTrimStart
  • StringUnescape
  • StringUnescapeDecode
  • StringUnescapeJson
  • StringWktGeom
  • SystemCpuCount
  • SystemGpgpuCount
  • SystemGpgpus
  • Tan
  • Tanh
  • Tgamma
  • TileAbs
  • TileAcos
  • TileAcosh
  • TileAsin
  • TileAspect
  • TileAtan
  • TileAtan2
  • TileAtanh
  • TileBgrHcy
  • TileBgrHsi
  • TileBgrHsl
  • TileBgrHsv
  • TileBlur
  • TileBlurDirection
  • TileBlurGaussian
  • TileCbrt
  • TileCeil
  • TileChannel
  • TileChannelCount
  • TileChannels
  • TileChannelsConcat
  • TileCombine
  • TileCompare
  • TileContrast
  • TileCos
  • TileCosh
  • TileCut
  • TileCutBorder
  • TileCutRect
  • TileEdges
  • TileEdgesDirection
  • TileErf
  • TileErfc
  • TileExp
  • TileExp10
  • TileExp2
  • TileExpm1
  • TileFill
  • TileFloor
  • TileFloorDecs
  • TileFract
  • TileFractDecs
  • TileHcyBgr
  • TileHsiBgr
  • TileHslBgr
  • TileHsvBgr
  • TileHypot
  • TileJ0
  • TileJ1
  • TileJn
  • TileLgamma
  • TileLog
  • TileLog10
  • TileLog1p
  • TileLog2
  • TileMakeNew
  • TileMaskExtract
  • TileMaskReplace
  • TileMax
  • TileMin
  • TileNoise
  • TileRcbrt
  • TileRound
  • TileRoundDecs
  • TileRsqrt
  • TileSharpen
  • TileSign
  • TileSin
  • TileSinh
  • TileSlope
  • TileSqrt
  • TileTan
  • TileTanh
  • TileTgamma
  • TileToValues
  • TileToValuesX2
  • TileToValuesX3
  • TileToValuesX4
  • TileTrunc
  • TileTruncDecs
  • TileUpdatePyramids
  • TileY0
  • TileY1
  • TileYn
  • Trunc
  • TruncDecs
  • UuidMakeNew
  • ValueCount
  • ValueMax
  • ValueMin
  • ValueSequence
  • VectorBgrHcy
  • VectorBgrHsi
  • VectorBgrHsl
  • VectorBgrHsv
  • VectorHcyBgr
  • VectorHsiBgr
  • VectorHslBgr
  • VectorHsvBgr
  • VectorMakeX2
  • VectorMakeX3
  • VectorMakeX4
  • VectorValue
  • VectorValues
  • Y0
  • Y1
  • Yn

Manifold imports everything.

Manifold imports everything: Manifold works with hundreds of different data sources, including almost any file format, database, or web protocol imaginable. The image shows parcel data in Australia imported from a MapInfo TAB format file.

About Manifold

Manifold is a deep technology company creating advanced, parallel algorithms, next-level technology, and computation know-how that powers faster performance and smarter operations.

License Manifold® technology to power your company's products, or take advantage of Manifold's off-the-shelf commercial products. Jump decades ahead of your competition.

Manifold® brand products deliver quality, performance and value in the world's most sophisticated, most modern, and most powerful spatial products for GIS, ETL, DBMS, and Data Science. Total integration ensures ease of use, amazing speed, and unbeatably low cost of ownership. Tell your friends!

Questions? Contact We're happy to help!