<?xml version="1.0" encoding="utf-8"?>
<feed xmlns="http://www.w3.org/2005/Atom"><title>Apache Lucene - core/news</title><link href="/" rel="alternate"></link><link href="/feeds/core/news.atom.xml" rel="self"></link><id>/</id><updated>2024-02-20T00:00:00+00:00</updated><subtitle></subtitle><subtitle></subtitle><entry><title>Apache Lucene™ 9.10.0 available</title><link href="/" rel="alternate"></link><published>2024-02-20T00:00:00+00:00</published><updated>2024-02-20T00:00:00+00:00</updated><author><name>Lucene Developers</name></author><id>tag:None,2024-02-20:/</id><summary type="html">&lt;p&gt;The Lucene PMC is pleased to announce the release of Apache Lucene 9.10.0.&lt;/p&gt;
&lt;p&gt;Apache Lucene is a high-performance, full-featured search engine library written entirely in Java. It is a technology suitable for nearly any application that requires structured search, full-text search, faceting, nearest-neighbor search across high-dimensionality vectors, spell …&lt;/p&gt;</summary><content type="html">&lt;p&gt;The Lucene PMC is pleased to announce the release of Apache Lucene 9.10.0.&lt;/p&gt;
&lt;p&gt;Apache Lucene is a high-performance, full-featured search engine library written entirely in Java. It is a technology suitable for nearly any application that requires structured search, full-text search, faceting, nearest-neighbor search across high-dimensionality vectors, spell correction or query suggestions.&lt;/p&gt;
&lt;p&gt;This release contains numerous bug fixes, optimizations, and improvements, some of which are highlighted below. The release is available for immediate download at:&lt;/p&gt;
&lt;p&gt;&lt;a href="https://lucene.apache.org/core/downloads.html"&gt;https://lucene.apache.org/core/downloads.html&lt;/a&gt;&lt;/p&gt;
&lt;h3 id="lucene-9100-release-highlights"&gt;Lucene 9.10.0 Release Highlights:&lt;/h3&gt;
&lt;h4 id="new-features"&gt;New features&lt;/h4&gt;
&lt;ul&gt;
&lt;li&gt;Support for similarity-based vector searches, ie. finding all nearest neighbors whose similarity is greater than a configured threshold from a query vector. See [Byte|Float]VectorSimilarityQuery.&lt;/li&gt;
&lt;li&gt;Index sorting is now compatible with block joins. See IndexWriterConfig#setParentField.&lt;/li&gt;
&lt;li&gt;MMapDirectory now takes advantage of the now finalized JDK foreign memory API internally when running on Java 22 (or later). This was only supported with Java 19 to 21 until now.&lt;/li&gt;
&lt;li&gt;SIMD vectorization now takes advantage of JDK vector incubator on Java 22. This was only supported with Java 20 or 21 until now.&lt;/li&gt;
&lt;/ul&gt;
&lt;h4 id="optimizations"&gt;Optimizations&lt;/h4&gt;
&lt;ul&gt;
&lt;li&gt;Tail postings are now encoded using group-varint. This yielded speedups on queries that match lots of terms that have short postings lists in Lucene's nightly benchmarks.&lt;/li&gt;
&lt;li&gt;Range queries on points now exit earlier when evaluating a segment that has no matches. This will improve performance when intersected with other queries that have a high up-front cost such as multi-term queries.&lt;/li&gt;
&lt;li&gt;BooleanQueries that mix SHOULD and FILTER clauses now propagate minimum competitive scores to the SHOULD clauses, yielding significant speedups for top-k queries sorted by descending score.&lt;/li&gt;
&lt;li&gt;IndexSearcher#count has been optimized on pure disjunctions of two term queries.&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;Please read CHANGES.txt for a full list of new features and changes:&lt;/p&gt;
&lt;p&gt;&lt;a href="https://lucene.apache.org/core/9_10_0/changes/Changes.html"&gt;https://lucene.apache.org/core/9_10_0/changes/Changes.html&lt;/a&gt;&lt;/p&gt;</content><category term="core/news"></category></entry><entry><title>Apache Lucene™ 8.11.3 available</title><link href="/" rel="alternate"></link><published>2024-02-08T00:00:00+00:00</published><updated>2024-02-08T00:00:00+00:00</updated><author><name>Lucene Developers</name></author><id>tag:None,2024-02-08:/</id><summary type="html">&lt;p&gt;The Lucene PMC is pleased to announce the release of Apache Lucene 8.11.3.&lt;/p&gt;
&lt;p&gt;Apache Lucene is a high-performance, full-featured text search engine library written entirely in Java. It is a technology suitable for nearly any application that requires full-text search, especially cross-platform.&lt;/p&gt;
&lt;p&gt;This release contains numerous bug fixes …&lt;/p&gt;</summary><content type="html">&lt;p&gt;The Lucene PMC is pleased to announce the release of Apache Lucene 8.11.3.&lt;/p&gt;
&lt;p&gt;Apache Lucene is a high-performance, full-featured text search engine library written entirely in Java. It is a technology suitable for nearly any application that requires full-text search, especially cross-platform.&lt;/p&gt;
&lt;p&gt;This release contains numerous bug fixes, optimizations, and improvements, some of which are highlighted below. The release is available for immediate download at:&lt;/p&gt;
&lt;p&gt;&lt;a href="https://lucene.apache.org/core/downloads.html"&gt;https://lucene.apache.org/core/downloads.html&lt;/a&gt;&lt;/p&gt;
&lt;h3 id="lucene-8113-release-highlights"&gt;Lucene 8.11.3 Release Highlights:&lt;/h3&gt;
&lt;ul&gt;
&lt;li&gt;A number of bugs in polygon tessellating have been fixed.&lt;/li&gt;
&lt;li&gt;GC Load during indexing has been reduced by estimating FST BysteStore block size.&lt;/li&gt;
&lt;li&gt;BKD trees will no longer possibly overflow when more than 4 billion points are added.&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;Please read CHANGES.txt for a full list of changes:&lt;/p&gt;
&lt;p&gt;&lt;a href="https://lucene.apache.org/core/8_11_3/changes/Changes.html"&gt;https://lucene.apache.org/core/8_11_3/changes/Changes.html&lt;/a&gt;&lt;/p&gt;</content><category term="core/news"></category></entry><entry><title>Apache Lucene™ 9.9.2 available</title><link href="/" rel="alternate"></link><published>2024-01-29T00:00:00+00:00</published><updated>2024-01-29T00:00:00+00:00</updated><author><name>Lucene Developers</name></author><id>tag:None,2024-01-29:/</id><summary type="html">&lt;p&gt;The Lucene PMC is pleased to announce the release of Apache Lucene 9.9.2.&lt;/p&gt;
&lt;p&gt;Apache Lucene is a high-performance, full-featured search engine library written entirely in Java. It is a technology suitable for nearly any application that requires structured search, full-text search, faceting, nearest-neighbor search across high-dimensionality vectors, spell …&lt;/p&gt;</summary><content type="html">&lt;p&gt;The Lucene PMC is pleased to announce the release of Apache Lucene 9.9.2.&lt;/p&gt;
&lt;p&gt;Apache Lucene is a high-performance, full-featured search engine library written entirely in Java. It is a technology suitable for nearly any application that requires structured search, full-text search, faceting, nearest-neighbor search across high-dimensionality vectors, spell correction or query suggestions.&lt;/p&gt;
&lt;p&gt;This release contains numerous bug fixes, optimizations, and improvements, some of which are highlighted below. The release is available for immediate download at:&lt;/p&gt;
&lt;p&gt;&lt;a href="https://lucene.apache.org/core/downloads.html"&gt;https://lucene.apache.org/core/downloads.html&lt;/a&gt;&lt;/p&gt;
&lt;h3 id="lucene-992-release-highlights"&gt;Lucene 9.9.2 Release Highlights:&lt;/h3&gt;
&lt;h4 id="bug-fixes"&gt;Bug fixes&lt;/h4&gt;
&lt;ul&gt;
&lt;li&gt;Fix NPE when sampling for quantization in Lucene99HnswScalarQuantizedVectorsFormat (Ben Trent)&lt;/li&gt;
&lt;li&gt;Rollback the tmp storage of BytesRefHash to -1 after sort (Guo Feng)&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;Please read CHANGES.txt for a full list of changes:&lt;/p&gt;
&lt;p&gt;&lt;a href="https://lucene.apache.org/core/9_9_2/changes/Changes.html"&gt;https://lucene.apache.org/core/9_9_2/changes/Changes.html&lt;/a&gt;&lt;/p&gt;</content><category term="core/news"></category></entry><entry><title>Apache Lucene™ 9.9.1 available</title><link href="/" rel="alternate"></link><published>2023-12-16T00:00:00+00:00</published><updated>2023-12-16T00:00:00+00:00</updated><author><name>Lucene Developers</name></author><id>tag:None,2023-12-16:/</id><summary type="html">&lt;p&gt;The Lucene PMC is pleased to announce the release of Apache Lucene 9.9.1.&lt;/p&gt;
&lt;p&gt;Apache Lucene is a high-performance, full-featured search engine library written entirely in Java. It is a technology suitable for nearly any application that requires structured search, full-text search, faceting, nearest-neighbor search across high-dimensionality vectors, spell …&lt;/p&gt;</summary><content type="html">&lt;p&gt;The Lucene PMC is pleased to announce the release of Apache Lucene 9.9.1.&lt;/p&gt;
&lt;p&gt;Apache Lucene is a high-performance, full-featured search engine library written entirely in Java. It is a technology suitable for nearly any application that requires structured search, full-text search, faceting, nearest-neighbor search across high-dimensionality vectors, spell correction or query suggestions.&lt;/p&gt;
&lt;p&gt;This release contains numerous bug fixes, optimizations, and improvements, some of which are highlighted below. The release is available for immediate download at:&lt;/p&gt;
&lt;p&gt;&lt;a href="https://lucene.apache.org/core/downloads.html"&gt;https://lucene.apache.org/core/downloads.html&lt;/a&gt;&lt;/p&gt;
&lt;h3 id="lucene-991-release-highlights"&gt;Lucene 9.9.1 Release Highlights:&lt;/h3&gt;
&lt;h4 id="bug-fixes"&gt;Bug fixes&lt;/h4&gt;
&lt;ul&gt;
&lt;li&gt;JVM SIGSEGV crash when compiling computeCommonPrefixLengthAndBuildHistogram (Chris Hegarty)&lt;/li&gt;
&lt;li&gt;Push and pop OutputAccumulator as IntersectTermsEnumFrames are pushed and popped (Guo Feng, Mike McCandless)&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;Please read CHANGES.txt for a full list of changes:&lt;/p&gt;
&lt;p&gt;&lt;a href="https://lucene.apache.org/core/9_9_1/changes/Changes.html"&gt;https://lucene.apache.org/core/9_9_1/changes/Changes.html&lt;/a&gt;&lt;/p&gt;</content><category term="core/news"></category></entry><entry><title>Apache Lucene™ 9.9.0 available</title><link href="/" rel="alternate"></link><published>2023-12-04T00:00:00+00:00</published><updated>2023-12-04T00:00:00+00:00</updated><author><name>Lucene Developers</name></author><id>tag:None,2023-12-04:/</id><summary type="html">&lt;p&gt;The Lucene PMC is pleased to announce the release of Apache Lucene 9.9.0.&lt;/p&gt;
&lt;p&gt;Apache Lucene is a high-performance, full-featured search engine library
written entirely in Java. It is a technology suitable for nearly any
application that requires structured search, full-text search, faceting,
nearest-neighbor search across high-dimensionality vectors, spell …&lt;/p&gt;</summary><content type="html">&lt;p&gt;The Lucene PMC is pleased to announce the release of Apache Lucene 9.9.0.&lt;/p&gt;
&lt;p&gt;Apache Lucene is a high-performance, full-featured search engine library
written entirely in Java. It is a technology suitable for nearly any
application that requires structured search, full-text search, faceting,
nearest-neighbor search across high-dimensionality vectors, spell
correction or query suggestions.&lt;/p&gt;
&lt;p&gt;This release contains numerous bug fixes, optimizations, and
improvements, some of which are highlighted below. The release is
available for immediate download at:&lt;/p&gt;
&lt;p&gt;&lt;a href="https://lucene.apache.org/core/downloads.html"&gt;https://lucene.apache.org/core/downloads.html&lt;/a&gt;&lt;/p&gt;
&lt;h3 id="lucene-990-release-highlights"&gt;Lucene 9.9.0 Release Highlights:&lt;/h3&gt;
&lt;h4 id="new-features"&gt;New Features&lt;/h4&gt;
&lt;ul&gt;
&lt;li&gt;Add int8 scalar quantization to the HNSW vector format. This
   optionally allows for more compact lossy storage for the vectors,
   requiring approximately 4x less memory for fast HNSW search.&lt;/li&gt;
&lt;li&gt;HNSW graph now can be merged with multiple threads, leveraging the
   same infrastructure that inter-segment concurrency utilizes.&lt;/li&gt;
&lt;/ul&gt;
&lt;h4 id="improvements"&gt;Improvements&lt;/h4&gt;
&lt;ul&gt;
&lt;li&gt;Speed up Panama vector support, use FMA, and test improvements. &lt;/li&gt;
&lt;li&gt;FSTCompiler can now approximately limit how much RAM it uses to share 
   suffixes during FST construction using the suffixRAMLimitMB method. &lt;/li&gt;
&lt;/ul&gt;
&lt;h4 id="optimizations"&gt;Optimizations&lt;/h4&gt;
&lt;ul&gt;
&lt;li&gt;Faster top-level conjunctions on term queries when sorting by
   descending score.&lt;/li&gt;
&lt;li&gt;Change Postings back to using FOR in Lucene99PostingsFormat. Freqs,
   positions and offset keep using PFOR.&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;... plus a multitude of helpful bug fixes!&lt;/p&gt;
&lt;p&gt;Please read CHANGES.txt for a full list of new features and changes:&lt;/p&gt;
&lt;p&gt;&lt;a href="https://lucene.apache.org/core/9_9_0/changes/Changes.html"&gt;https://lucene.apache.org/core/9_9_0/changes/Changes.html&lt;/a&gt;&lt;/p&gt;</content><category term="core/news"></category></entry><entry><title>Apache Lucene™ 9.8.0 available</title><link href="/" rel="alternate"></link><published>2023-09-28T00:00:00+00:00</published><updated>2023-09-28T00:00:00+00:00</updated><author><name>Lucene Developers</name></author><id>tag:None,2023-09-28:/</id><summary type="html">&lt;p&gt;The Lucene PMC is pleased to announce the release of Apache Lucene 9.8.0.&lt;/p&gt;
&lt;p&gt;Apache Lucene is a high-performance, full-featured search engine library written entirely in Java. It is a technology suitable for nearly any application that requires structured search, full-text search, faceting, nearest-neighbor search across high-dimensionality vectors, spell …&lt;/p&gt;</summary><content type="html">&lt;p&gt;The Lucene PMC is pleased to announce the release of Apache Lucene 9.8.0.&lt;/p&gt;
&lt;p&gt;Apache Lucene is a high-performance, full-featured search engine library written entirely in Java. It is a technology suitable for nearly any application that requires structured search, full-text search, faceting, nearest-neighbor search across high-dimensionality vectors, spell correction or query suggestions.&lt;/p&gt;
&lt;p&gt;This release contains numerous bug fixes, optimizations, and improvements, some of which are highlighted below. The release is available for immediate download at:&lt;/p&gt;
&lt;p&gt;&lt;a href="https://lucene.apache.org/core/downloads.html"&gt;https://lucene.apache.org/core/downloads.html&lt;/a&gt;&lt;/p&gt;
&lt;h3 id="lucene-980-release-highlights"&gt;Lucene 9.8.0 Release Highlights:&lt;/h3&gt;
&lt;h4 id="optimizations"&gt;Optimizations&lt;/h4&gt;
&lt;ul&gt;
&lt;li&gt;Faster computation of top-k hits on boolean queries. Lucene's nightly benchmarks report a 20%-30% speedup for disjunctive queries and a 11%-13% speedup for conjunctive queries since Lucene 9.7. Disjunctive queries with many and/or high-frequency terms should see even higher speedups.&lt;/li&gt;
&lt;li&gt;Faster computation of top-k hits when sorting by field. Lucene's nightly benchmarks report speedups between 7% and 33% since 9.7 depending on the type and cardinality of the field that is used for sorting.&lt;/li&gt;
&lt;li&gt;Faster indexing of numeric doc values when index sorting is turned on.&lt;/li&gt;
&lt;li&gt;Expressions now evaluate all arguments in a fully lazy manner, which may provide significant speedups and throughput improvements for heavy expression users.&lt;/li&gt;
&lt;/ul&gt;
&lt;h4 id="api-changes"&gt;API Changes&lt;/h4&gt;
&lt;ul&gt;
&lt;li&gt;Move max vector dims limit to Codec (Mayya Sharipova)&lt;/li&gt;
&lt;/ul&gt;
&lt;h4 id="new-features"&gt;New features&lt;/h4&gt;
&lt;ul&gt;
&lt;li&gt;Introduced LeafCollector#finish, a hook that runs after collection has finished running on a leaf.&lt;/li&gt;
&lt;li&gt;Add "KnnCollector" to "LeafReader" and "KnnVectorReader" so that custom collection of vector search results can be provided. The first custom collector provides "ToParentBlockJoin[Float|Byte]KnnVectorQuery" joining child vector documents with their parent documents.&lt;/li&gt;
&lt;li&gt;Add support for recursive graph bisection, also called bipartite graph partitioning, and often abbreviated BP, an algorithm for reordering doc IDs that results in more compact postings and faster queries, especially conjunctions.&lt;/li&gt;
&lt;/ul&gt;
&lt;h4 id="bug-fixes"&gt;Bug fixes&lt;/h4&gt;
&lt;ul&gt;
&lt;li&gt;Fix HNSW graph search bug that potentially leaked unapproved docs&lt;/li&gt;
&lt;li&gt;Fix bug in TermsEnum#seekCeil on doc values terms enums that causes IndexOutOfBoundsException.&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;Please read CHANGES.txt for a full list of new features and changes:&lt;/p&gt;
&lt;p&gt;&lt;a href="https://lucene.apache.org/core/9_8_0/changes/Changes.html"&gt;https://lucene.apache.org/core/9_8_0/changes/Changes.html&lt;/a&gt;&lt;/p&gt;</content><category term="core/news"></category></entry><entry><title>Apache Lucene™ 9.7.0 available</title><link href="/" rel="alternate"></link><published>2023-06-25T00:00:00+00:00</published><updated>2023-06-25T00:00:00+00:00</updated><author><name>Lucene Developers</name></author><id>tag:None,2023-06-25:/</id><summary type="html">&lt;p&gt;The Lucene PMC is pleased to announce the release of Apache Lucene 9.7.0.&lt;/p&gt;
&lt;p&gt;Apache Lucene is a high-performance, full-featured search engine library written entirely in Java. It is a technology suitable for nearly any application that requires structured search, full-text search, faceting, nearest-neighbor search across high-dimensionality vectors, spell …&lt;/p&gt;</summary><content type="html">&lt;p&gt;The Lucene PMC is pleased to announce the release of Apache Lucene 9.7.0.&lt;/p&gt;
&lt;p&gt;Apache Lucene is a high-performance, full-featured search engine library written entirely in Java. It is a technology suitable for nearly any application that requires structured search, full-text search, faceting, nearest-neighbor search across high-dimensionality vectors, spell correction or query suggestions.&lt;/p&gt;
&lt;p&gt;This release contains numerous bug fixes, optimizations, and improvements, some of which are highlighted below. The release is available for immediate download at:&lt;/p&gt;
&lt;p&gt;&lt;a href="https://lucene.apache.org/core/downloads.html"&gt;https://lucene.apache.org/core/downloads.html&lt;/a&gt;&lt;/p&gt;
&lt;h3 id="lucene-970-release-highlights"&gt;Lucene 9.7.0 Release Highlights:&lt;/h3&gt;
&lt;h4 id="new-features"&gt;New features&lt;/h4&gt;
&lt;ul&gt;
&lt;li&gt;
&lt;p&gt;The new IndexWriter#updateDocuments(Query, Iterable) allows updating multiple documents that match a query at the same time.&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;Function queries can now compute similarity scores between kNN vectors.&lt;/p&gt;
&lt;/li&gt;
&lt;/ul&gt;
&lt;h4 id="optimizations"&gt;Optimizations&lt;/h4&gt;
&lt;ul&gt;
&lt;li&gt;
&lt;p&gt;KNN indexing and querying can now take advantage of vectorization for distance computation between vectors. To enable this, use exactly Java 20 or 21, and pass --add-modules jdk.incubator.vector as a command-line parameter to the Java program.&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;KNN queries now run concurrently if the IndexSearcher has been created with an executor.&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;Queries sorted by field are now able to dynamically prune hits only using the after value. This yields major speedups when paginating deeply.&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;Reduced merge-time overhead of computing the number of soft deletes.&lt;/p&gt;
&lt;/li&gt;
&lt;/ul&gt;
&lt;h4 id="changes-in-runtime-behavior"&gt;Changes in runtime behavior&lt;/h4&gt;
&lt;ul&gt;
&lt;li&gt;KNN vectors are now disallowed to have non-finite values such as NaN or ±Infinity.&lt;/li&gt;
&lt;/ul&gt;
&lt;h4 id="bug-fixes"&gt;Bug fixes&lt;/h4&gt;
&lt;ul&gt;
&lt;li&gt;
&lt;p&gt;Backward reading is no longer an adversarial case for BufferedIndexInput, used by NIOFSDirectory and SimpleFSDirectory. This addresses a performance bug when performing terms dictionary lookups with either of these directories.&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;GraphTokenStreamFiniteStrings#articulationPointsRecurse may no longer overflow the stack.&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;... plus a number of helpful bug fixes!&lt;/p&gt;
&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;Please read CHANGES.txt for a full list of new features and changes:&lt;/p&gt;
&lt;p&gt;&lt;a href="https://lucene.apache.org/core/9_7_0/changes/Changes.html"&gt;https://lucene.apache.org/core/9_7_0/changes/Changes.html&lt;/a&gt;&lt;/p&gt;</content><category term="core/news"></category></entry><entry><title>Apache Lucene™ 9.6.0 available</title><link href="/" rel="alternate"></link><published>2023-05-09T00:00:00+00:00</published><updated>2023-05-09T00:00:00+00:00</updated><author><name>Lucene Developers</name></author><id>tag:None,2023-05-09:/</id><summary type="html">&lt;p&gt;The Lucene PMC is pleased to announce the release of Apache Lucene 9.6.0.&lt;/p&gt;
&lt;p&gt;Apache Lucene is a high-performance, full-featured search engine library written entirely in Java. It is a technology suitable for nearly any application that requires structured search, full-text search, faceting, nearest-neighbor search across high-dimensionality vectors, spell …&lt;/p&gt;</summary><content type="html">&lt;p&gt;The Lucene PMC is pleased to announce the release of Apache Lucene 9.6.0.&lt;/p&gt;
&lt;p&gt;Apache Lucene is a high-performance, full-featured search engine library written entirely in Java. It is a technology suitable for nearly any application that requires structured search, full-text search, faceting, nearest-neighbor search across high-dimensionality vectors, spell correction or query suggestions.&lt;/p&gt;
&lt;p&gt;This release contains numerous bug fixes, optimizations, and improvements, some of which are highlighted below. The release is available for immediate download at:&lt;/p&gt;
&lt;p&gt;&lt;a href="https://lucene.apache.org/core/downloads.html"&gt;https://lucene.apache.org/core/downloads.html&lt;/a&gt;&lt;/p&gt;
&lt;h3 id="lucene-960-release-highlights"&gt;Lucene 9.6.0 Release Highlights:&lt;/h3&gt;
&lt;ul&gt;
&lt;li&gt;Introduce a new KeywordField for simple and efficient filtering, sorting and faceting.&lt;/li&gt;
&lt;li&gt;Add support for Java 20 foreign memory API. If exactly Java 19 or 20 is used, MMapDirectory will mmap Lucene indexes in chunks of 16 GiB (instead of 1 GiB) and indexes closed while queries are running can no longer crash the JVM.&lt;/li&gt;
&lt;li&gt;Improved performance for TermInSetQuery, PrefixQuery, WildcardQuery and TermRangeQuery&lt;/li&gt;
&lt;li&gt;Lower memory usage for BloomFilteringPostingsFormat&lt;/li&gt;
&lt;li&gt;Faster merges for HNSW indexes&lt;/li&gt;
&lt;li&gt;Improvements to concurrent indexing throughput under heavy load&lt;/li&gt;
&lt;li&gt;Correct equals implementation in SynonymQuery&lt;/li&gt;
&lt;li&gt;'explain' is now implemented on TermAutomatonQuery&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;Please read CHANGES.txt for a full list of new features and changes:&lt;/p&gt;
&lt;p&gt;&lt;a href="https://lucene.apache.org/core/9_6_0/changes/Changes.html"&gt;https://lucene.apache.org/core/9_6_0/changes/Changes.html&lt;/a&gt;&lt;/p&gt;</content><category term="core/news"></category></entry><entry><title>Apache Lucene™ 9.5.0 available</title><link href="/" rel="alternate"></link><published>2023-01-30T00:00:00+00:00</published><updated>2023-01-30T00:00:00+00:00</updated><author><name>Lucene Developers</name></author><id>tag:None,2023-01-30:/</id><summary type="html">&lt;p&gt;The Lucene PMC is pleased to announce the release of Apache Lucene 9.5.0.&lt;/p&gt;
&lt;p&gt;Apache Lucene is a high-performance, full-featured search engine library written entirely in Java. It is a technology suitable for nearly any application that requires structured search, full-text search, faceting, nearest-neighbor search across high-dimensionality vectors, spell …&lt;/p&gt;</summary><content type="html">&lt;p&gt;The Lucene PMC is pleased to announce the release of Apache Lucene 9.5.0.&lt;/p&gt;
&lt;p&gt;Apache Lucene is a high-performance, full-featured search engine library written entirely in Java. It is a technology suitable for nearly any application that requires structured search, full-text search, faceting, nearest-neighbor search across high-dimensionality vectors, spell correction or query suggestions.&lt;/p&gt;
&lt;p&gt;This release contains numerous bug fixes, optimizations, and improvements, some of which are highlighted below. The release is available for immediate download at:&lt;/p&gt;
&lt;p&gt;&lt;a href="https://lucene.apache.org/core/downloads.html"&gt;https://lucene.apache.org/core/downloads.html&lt;/a&gt;&lt;/p&gt;
&lt;h3 id="lucene-950-release-highlights"&gt;Lucene 9.5.0 Release Highlights:&lt;/h3&gt;
&lt;h4 id="new-features"&gt;New features&lt;/h4&gt;
&lt;ul&gt;
&lt;li&gt;Added KnnByteVectorField and ByteVectorQuery that are specialized for indexing and querying byte-sized vectors. Deprecated KnnVectorField, KnnVectorQuery and LeafReader#getVectorValues in favour of the newly introduced KnnFloatVectorField, KnnFloatVectorQuery and LeafReader#getFloatVectorValues that are specialized for float vectors.&lt;/li&gt;
&lt;li&gt;Added IntField, LongField, FloatField and DoubleField: easy to use numeric fields that perform well both for filtering and sorting.&lt;/li&gt;
&lt;li&gt;Support for Java 19 foreign memory access ("project Panama") was enabled by default removing the need to provide the "--enable-preview" flag.&lt;/li&gt;
&lt;li&gt;Added ByteWritesTrackingDirectoryWrapper to expose metrics for bytes merged, flushed, and overall write amplification factor.&lt;/li&gt;
&lt;/ul&gt;
&lt;h4 id="optimizations"&gt;Optimizations&lt;/h4&gt;
&lt;ul&gt;
&lt;li&gt;Improved storage efficiency of connections in the HNSW graph used for vector search&lt;/li&gt;
&lt;li&gt;Added  new stored fields and term vectors interfaces: IndexReader#storedFields and IndexReader#termVectors. These do not rely upon ThreadLocal storage for each index segment, which can greatly reduce RAM requirements when there are many threads and/or segments.&lt;/li&gt;
&lt;li&gt;Several improvements were made to IndexSortSortedNumericDocValuesRangeQuery including query execution optimization with points for descending sorts and BoundedDocIdSetIterator construction sped up using bkd binary search.&lt;/li&gt;
&lt;/ul&gt;
&lt;h4 id="other"&gt;Other&lt;/h4&gt;
&lt;ul&gt;
&lt;li&gt;Moved DocValuesNumbersQuery from sandbox to NumericDocValuesField#newSlowSetQuery&lt;/li&gt;
&lt;li&gt;Fix exponential runtime for nested BooleanQuery#rewrite with non scoring clauses&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;Please read CHANGES.txt for a full list of new features and changes:&lt;/p&gt;
&lt;p&gt;&lt;a href="https://lucene.apache.org/core/9_5_0/changes/Changes.html"&gt;https://lucene.apache.org/core/9_5_0/changes/Changes.html&lt;/a&gt;&lt;/p&gt;</content><category term="core/news"></category></entry><entry><title>Apache Lucene™ 9.4.2 available</title><link href="/" rel="alternate"></link><published>2022-11-21T00:00:00+00:00</published><updated>2022-11-21T00:00:00+00:00</updated><author><name>Lucene Developers</name></author><id>tag:None,2022-11-21:/</id><summary type="html">&lt;p&gt;The Lucene PMC is pleased to announce the release of Apache Lucene 9.4.2.&lt;/p&gt;
&lt;p&gt;Apache Lucene is a high-performance, full-featured search engine library written entirely in Java. It is a technology suitable for nearly any application that requires structured search, full-text search, faceting, nearest-neighbor search across high-dimensionality vectors, spell …&lt;/p&gt;</summary><content type="html">&lt;p&gt;The Lucene PMC is pleased to announce the release of Apache Lucene 9.4.2.&lt;/p&gt;
&lt;p&gt;Apache Lucene is a high-performance, full-featured search engine library written entirely in Java. It is a technology suitable for nearly any application that requires structured search, full-text search, faceting, nearest-neighbor search across high-dimensionality vectors, spell correction or query suggestions.&lt;/p&gt;
&lt;p&gt;This release contains numerous bug fixes, optimizations, and improvements, some of which are highlighted below. The release is available for immediate download at:&lt;/p&gt;
&lt;p&gt;&lt;a href="https://lucene.apache.org/core/downloads.html"&gt;https://lucene.apache.org/core/downloads.html&lt;/a&gt;&lt;/p&gt;
&lt;h3 id="lucene-942-release-highlights"&gt;Lucene 9.4.2 Release Highlights:&lt;/h3&gt;
&lt;ul&gt;
&lt;li&gt;Fixed integer overflow when opening segments containing more than ~16M KNN vectors.&lt;/li&gt;
&lt;li&gt;Fixed cost computation of BitSets created via DocIdSetBuilder, such as for multi-term queries. This may improve performance of multi-term queries.&lt;/li&gt;
&lt;li&gt;CheckIndex now verifies the consistency of KNN vectors more thoroughly.&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;Please read CHANGES.txt for a full list of changes:&lt;/p&gt;
&lt;p&gt;&lt;a href="https://lucene.apache.org/core/9_4_2/changes/Changes.html"&gt;https://lucene.apache.org/core/9_4_2/changes/Changes.html&lt;/a&gt;&lt;/p&gt;</content><category term="core/news"></category></entry><entry><title>Apache Lucene™ 9.4.1 available</title><link href="/" rel="alternate"></link><published>2022-10-24T00:00:00+00:00</published><updated>2022-10-24T00:00:00+00:00</updated><author><name>Lucene Developers</name></author><id>tag:None,2022-10-24:/</id><summary type="html">&lt;p&gt;The Lucene PMC is pleased to announce the release of Apache Lucene 9.4.1.&lt;/p&gt;
&lt;p&gt;Apache Lucene is a high-performance, full-featured search engine library written entirely in Java. It is a technology suitable for nearly any application that requires structured search, full-text search, faceting, nearest-neighbor search across high-dimensionality vectors, spell …&lt;/p&gt;</summary><content type="html">&lt;p&gt;The Lucene PMC is pleased to announce the release of Apache Lucene 9.4.1.&lt;/p&gt;
&lt;p&gt;Apache Lucene is a high-performance, full-featured search engine library written entirely in Java. It is a technology suitable for nearly any application that requires structured search, full-text search, faceting, nearest-neighbor search across high-dimensionality vectors, spell correction or query suggestions.&lt;/p&gt;
&lt;p&gt;This release contains numerous bug fixes, optimizations, and improvements, some of which are highlighted below. The release is available for immediate download at:&lt;/p&gt;
&lt;p&gt;&lt;a href="https://lucene.apache.org/core/downloads.html"&gt;https://lucene.apache.org/core/downloads.html&lt;/a&gt;&lt;/p&gt;
&lt;h3 id="lucene-941-release-highlights"&gt;Lucene 9.4.1 Release Highlights:&lt;/h3&gt;
&lt;ul&gt;
&lt;li&gt;When reading large segments, the kNN vectors format could fail with a validation error, preventing further writes or searches on the index. This bug is now fixed. Only version 9.4.0 was affected, so it is recommended to skip 9.4.0 if you are using kNN vectors.&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;Please read CHANGES.txt for a full list of changes:&lt;/p&gt;
&lt;p&gt;&lt;a href="https://lucene.apache.org/core/9_4_1/changes/Changes.html"&gt;https://lucene.apache.org/core/9_4_1/changes/Changes.html&lt;/a&gt;&lt;/p&gt;</content><category term="core/news"></category></entry><entry><title>Apache Lucene™ 9.4.0 available</title><link href="/" rel="alternate"></link><published>2022-09-30T00:00:00+00:00</published><updated>2022-09-30T00:00:00+00:00</updated><author><name>Lucene Developers</name></author><id>tag:None,2022-09-30:/</id><summary type="html">&lt;p&gt;The Lucene PMC is pleased to announce the release of Apache Lucene 9.4.0.&lt;/p&gt;
&lt;p&gt;Apache Lucene is a high-performance, full-featured search engine library written entirely in Java. It is a technology suitable for nearly any application that requires structured search, full-text search, faceting, nearest-neighbor search across high-dimensionality vectors, spell …&lt;/p&gt;</summary><content type="html">&lt;p&gt;The Lucene PMC is pleased to announce the release of Apache Lucene 9.4.0.&lt;/p&gt;
&lt;p&gt;Apache Lucene is a high-performance, full-featured search engine library written entirely in Java. It is a technology suitable for nearly any application that requires structured search, full-text search, faceting, nearest-neighbor search across high-dimensionality vectors, spell correction or query suggestions.&lt;/p&gt;
&lt;p&gt;This release contains numerous bug fixes, optimizations, and improvements, some of which are highlighted below. The release is available for immediate download at:&lt;/p&gt;
&lt;p&gt;&lt;a href="https://lucene.apache.org/core/downloads.html"&gt;https://lucene.apache.org/core/downloads.html&lt;/a&gt;&lt;/p&gt;
&lt;h3 id="lucene-940-release-highlights"&gt;Lucene 9.4.0 Release Highlights:&lt;/h3&gt;
&lt;h4 id="new-features"&gt;New features&lt;/h4&gt;
&lt;ul&gt;
&lt;li&gt;Added ShapeDocValues/Field, a unified abstraction to represent existing types: XY and lat/long.&lt;/li&gt;
&lt;li&gt;FacetSets can now be filtered using a Query via MatchingFacetSetCounts.&lt;/li&gt;
&lt;li&gt;SortField now allows control over whether to apply index-sort optimizations.&lt;/li&gt;
&lt;li&gt;Support for Java 19 foreign memory access ("project Panama") was added. Applications started with command line parameter "java --enable-preview" will automatically use the new foreign memory API of Java 19 to access indexes on disk with MMapDirectory. This is an opt-in feature and requires explicit Java command line flag passed to your application's Java process (e.g., modify startup parameters of Solr or Elasticsearch/Opensearch)! When enabled, Lucene logs a notice using java.util.logging. Please test thoroughly and report bugs/slowness to Lucene's mailing list. When the new API is used, MMapDirectory will mmap Lucene indexes in chunks of 16 GiB (instead of 1 GiB) and indexes closed while queries are running can no longer crash the JVM.&lt;/li&gt;
&lt;/ul&gt;
&lt;h4 id="optimizations"&gt;Optimizations&lt;/h4&gt;
&lt;ul&gt;
&lt;li&gt;Added support for dynamic pruning to queries sorted by a string field that is indexed with both terms and SORTED or SORTED_SET doc values. This can lead to dramatic speedups when applicable.&lt;/li&gt;
&lt;li&gt;TermInSetQuery is optimized for the case when one of its terms matches all docs in a segment, and it now provides cost estimation, making it usable with IndexOrDocValuesQuery for better query planning.&lt;/li&gt;
&lt;li&gt;KnnVector fields can now be stored with reduced (8-bit) precision, saving storage and yielding a small query latency improvement.&lt;/li&gt;
&lt;/ul&gt;
&lt;h4 id="other"&gt;Other&lt;/h4&gt;
&lt;ul&gt;
&lt;li&gt;KnnVector fields' HNSW graphs are now created incrementally when new documents are added, rather than all-at-once when flushing. This yields more consistent predictable behavior at the cost of an overall increase in indexing time.&lt;/li&gt;
&lt;li&gt;randomizedtesting dependency upgraded to 2.8.1&lt;/li&gt;
&lt;li&gt;addIndexes(CodecReader) now respects MergePolicy and MergeScheduler, enabling it to do its work concurrently.&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;Please read CHANGES.txt for a full list of new features and changes:&lt;/p&gt;
&lt;p&gt;&lt;a href="https://lucene.apache.org/core/9_4_0/changes/Changes.html"&gt;https://lucene.apache.org/core/9_4_0/changes/Changes.html&lt;/a&gt;&lt;/p&gt;</content><category term="core/news"></category></entry><entry><title>Apache Lucene™ 9.3.0 available</title><link href="/" rel="alternate"></link><published>2022-07-29T00:00:00+00:00</published><updated>2022-07-29T00:00:00+00:00</updated><author><name>Lucene Developers</name></author><id>tag:None,2022-07-29:/</id><summary type="html">&lt;p&gt;The Lucene PMC is pleased to announce the release of Apache Lucene 9.3.0.&lt;/p&gt;
&lt;p&gt;Apache Lucene is a high-performance, full-featured search engine library written entirely in Java. It is a technology suitable for nearly any application that requires structured search, full-text search, faceting, nearest-neighbor search across high-dimensionality vectors, spell …&lt;/p&gt;</summary><content type="html">&lt;p&gt;The Lucene PMC is pleased to announce the release of Apache Lucene 9.3.0.&lt;/p&gt;
&lt;p&gt;Apache Lucene is a high-performance, full-featured search engine library written entirely in Java. It is a technology suitable for nearly any application that requires structured search, full-text search, faceting, nearest-neighbor search across high-dimensionality vectors, spell correction or query suggestions.&lt;/p&gt;
&lt;p&gt;This release contains numerous bug fixes, optimizations, and improvements, some of which are highlighted below. The release is available for immediate download at:&lt;/p&gt;
&lt;p&gt;&lt;a href="https://lucene.apache.org/core/downloads.html"&gt;https://lucene.apache.org/core/downloads.html&lt;/a&gt;&lt;/p&gt;
&lt;h3 id="lucene-930-release-highlights"&gt;Lucene 9.3.0 Release Highlights:&lt;/h3&gt;
&lt;ul&gt;
&lt;li&gt;Merge on full flush is enabled now by default with a timeout of 500ms, giving the merge policy a chance to merge NRT segments together before publishing a new point-in-time view of the IndexReader. This should give queries a small performance boost in the near-realtime case, especially terms-dictionary-intensive queries like fuzzy queries.&lt;/li&gt;
&lt;li&gt;Add getAllChildren functionality to facets.&lt;/li&gt;
&lt;li&gt;Added facetsets module for high dimensional (hyper-rectangle) faceting. &lt;/li&gt;
&lt;li&gt;Top-level two-clause disjunctions sorted by score now use the block-max MAXSCORE algorithm, which introduced a 40%-75% speedup in our benchmarks.&lt;/li&gt;
&lt;li&gt;BooleanQuery can return quick counts for simple boolean queries.&lt;/li&gt;
&lt;li&gt;When running KnnVectorQuery with a filter, reuse the cached filter bit set.&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;Please read CHANGES.txt for a full list of new features and changes:&lt;/p&gt;
&lt;p&gt;&lt;a href="https://lucene.apache.org/core/9_3_0/changes/Changes.html"&gt;https://lucene.apache.org/core/9_3_0/changes/Changes.html&lt;/a&gt;&lt;/p&gt;</content><category term="core/news"></category></entry><entry><title>Apache Lucene™ 8.11.2 available</title><link href="/" rel="alternate"></link><published>2022-06-17T00:00:00+00:00</published><updated>2022-06-17T00:00:00+00:00</updated><author><name>Lucene Developers</name></author><id>tag:None,2022-06-17:/</id><summary type="html">&lt;p&gt;The Lucene PMC is pleased to announce the release of Apache Lucene 8.11.2.&lt;/p&gt;
&lt;p&gt;Apache Lucene is a high-performance, full-featured text search engine library written entirely in Java. It is a technology suitable for nearly any application that requires full-text search, especially cross-platform.&lt;/p&gt;
&lt;p&gt;This release contains numerous bug fixes …&lt;/p&gt;</summary><content type="html">&lt;p&gt;The Lucene PMC is pleased to announce the release of Apache Lucene 8.11.2.&lt;/p&gt;
&lt;p&gt;Apache Lucene is a high-performance, full-featured text search engine library written entirely in Java. It is a technology suitable for nearly any application that requires full-text search, especially cross-platform.&lt;/p&gt;
&lt;p&gt;This release contains numerous bug fixes, optimizations, and improvements, some of which are highlighted below. The release is available for immediate download at:&lt;/p&gt;
&lt;p&gt;&lt;a href="https://lucene.apache.org/core/downloads.html"&gt;https://lucene.apache.org/core/downloads.html&lt;/a&gt;&lt;/p&gt;
&lt;h3 id="lucene-8112-release-highlights"&gt;Lucene 8.11.2 Release Highlights:&lt;/h3&gt;
&lt;p&gt;Bug fixes&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;LUCENE-10564: Make sure SparseFixedBitSet#or updates ramBytesUsed.&lt;/li&gt;
&lt;li&gt;LUCENE-10477: Highlighter: WeightedSpanTermExtractor.extractWeightedSpanTerms to Query#rewrite
  multiple times if necessary.&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;Optimizations&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;LUCENE-10481: FacetsCollector will not request scores if it does not use them.&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;Please read CHANGES.txt for a full list of changes:&lt;/p&gt;
&lt;p&gt;&lt;a href="https://lucene.apache.org/core/8_11_2/changes/Changes.html"&gt;https://lucene.apache.org/core/8_11_2/changes/Changes.html&lt;/a&gt;&lt;/p&gt;</content><category term="core/news"></category></entry><entry><title>Apache Lucene™ 9.2.0 available</title><link href="/" rel="alternate"></link><published>2022-05-23T00:00:00+00:00</published><updated>2022-05-23T00:00:00+00:00</updated><author><name>Lucene Developers</name></author><id>tag:None,2022-05-23:/</id><summary type="html">&lt;p&gt;The Lucene PMC is pleased to announce the release of Apache Lucene 9.2.0.&lt;/p&gt;
&lt;p&gt;Apache Lucene is a high-performance, full-featured search engine library written entirely in Java. It is a technology suitable for nearly any application that requires structured search, full-text search, faceting, nearest-neighbor search across high-dimensionality vectors, spell …&lt;/p&gt;</summary><content type="html">&lt;p&gt;The Lucene PMC is pleased to announce the release of Apache Lucene 9.2.0.&lt;/p&gt;
&lt;p&gt;Apache Lucene is a high-performance, full-featured search engine library written entirely in Java. It is a technology suitable for nearly any application that requires structured search, full-text search, faceting, nearest-neighbor search across high-dimensionality vectors, spell correction or query suggestions.&lt;/p&gt;
&lt;p&gt;This release contains numerous bug fixes, optimizations, and improvements, some of which are highlighted below. The release is available for immediate download at:&lt;/p&gt;
&lt;p&gt;&lt;a href="https://lucene.apache.org/core/downloads.html"&gt;https://lucene.apache.org/core/downloads.html&lt;/a&gt;&lt;/p&gt;
&lt;h3 id="lucene-920-release-highlights"&gt;Lucene 9.2.0 Release Highlights:&lt;/h3&gt;
&lt;ul&gt;
&lt;li&gt;Numerous improvements to indexing and query performance for KNN vectors&lt;/li&gt;
&lt;li&gt;More efficient implementations for count operations on range queries&lt;/li&gt;
&lt;li&gt;A new FieldExistsQuery that chooses the best index structures to run over for you&lt;/li&gt;
&lt;li&gt;A new Persian stemmer&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;Please read CHANGES.txt for a full list of new features and changes:&lt;/p&gt;
&lt;p&gt;&lt;a href="https://lucene.apache.org/core/9_2_0/changes/Changes.html"&gt;https://lucene.apache.org/core/9_2_0/changes/Changes.html&lt;/a&gt;&lt;/p&gt;</content><category term="core/news"></category></entry><entry><title>Apache Lucene™ 9.1.0 available</title><link href="/" rel="alternate"></link><published>2022-03-22T00:00:00+00:00</published><updated>2022-03-22T00:00:00+00:00</updated><author><name>Lucene Developers</name></author><id>tag:None,2022-03-22:/</id><summary type="html">&lt;p&gt;The Lucene PMC is pleased to announce the release of Apache Lucene 9.1.0.&lt;/p&gt;
&lt;p&gt;Apache Lucene is a high-performance, full-featured search engine library written entirely in Java. It is a technology suitable for nearly any application that requires structured search, full-text search, faceting, nearest-neighbor search across high-dimensionality vectors, spell …&lt;/p&gt;</summary><content type="html">&lt;p&gt;The Lucene PMC is pleased to announce the release of Apache Lucene 9.1.0.&lt;/p&gt;
&lt;p&gt;Apache Lucene is a high-performance, full-featured search engine library written entirely in Java. It is a technology suitable for nearly any application that requires structured search, full-text search, faceting, nearest-neighbor search across high-dimensionality vectors, spell correction or query suggestions.&lt;/p&gt;
&lt;p&gt;This release contains numerous bug fixes, optimizations, and improvements, some of which are highlighted below. The release is available for immediate download at:&lt;/p&gt;
&lt;p&gt;&lt;a href="https://lucene.apache.org/core/downloads.html"&gt;https://lucene.apache.org/core/downloads.html&lt;/a&gt;&lt;/p&gt;
&lt;h3 id="lucene-910-release-highlights"&gt;Lucene 9.1.0 Release Highlights:&lt;/h3&gt;
&lt;h4 id="new-features"&gt;New features&lt;/h4&gt;
&lt;ul&gt;
&lt;li&gt;Lucene JARs are now proper Java modules, with module descriptors and dependency information&lt;/li&gt;
&lt;li&gt;Support for filtering in nearest-neighbor vector search&lt;/li&gt;
&lt;li&gt;Support for intervals queries in the standard query syntax&lt;/li&gt;
&lt;li&gt;A new token filter SpanishPluralStemFilter for precise stemming of Spanish plurals&lt;/li&gt;
&lt;/ul&gt;
&lt;h4 id="optimizations"&gt;Optimizations&lt;/h4&gt;
&lt;ul&gt;
&lt;li&gt;Up to 30% improvement in index throughput for high-dimensional vectors &lt;/li&gt;
&lt;li&gt;Up to 10% faster nearest neighbor searches on high-dimensional vectors&lt;/li&gt;
&lt;li&gt;Faster execution of "count" searches across different query types&lt;/li&gt;
&lt;li&gt;Faster counting for taxonomy facets&lt;/li&gt;
&lt;li&gt;Several other search speed-ups, including improvements to PointRangeQuery, MultiRangeQuery, and CoveringRangeQuery&lt;/li&gt;
&lt;/ul&gt;
&lt;h4 id="other"&gt;Other&lt;/h4&gt;
&lt;ul&gt;
&lt;li&gt;The test framework is now a module, so all classes have been moved from to org.apache.lucene.tests.* to avoid package name conflicts&lt;/li&gt;
&lt;li&gt;Lucene now faithfully implements the HNSW algorithm for nearest neighbor search by supporting multiple graph layers&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;… plus a number of helpful bug fixes!&lt;/p&gt;
&lt;p&gt;Please read CHANGES.txt for a full list of new features and changes:&lt;/p&gt;
&lt;p&gt;&lt;a href="https://lucene.apache.org/core/9_1_0/changes/Changes.html"&gt;https://lucene.apache.org/core/9_1_0/changes/Changes.html&lt;/a&gt;&lt;/p&gt;</content><category term="core/news"></category></entry><entry><title>Apache Lucene™ 8.11.1 available</title><link href="/" rel="alternate"></link><published>2021-12-16T00:00:00+00:00</published><updated>2021-12-16T00:00:00+00:00</updated><author><name>Lucene Developers</name></author><id>tag:None,2021-12-16:/</id><summary type="html">&lt;p&gt;The Lucene PMC is pleased to announce the release of Apache Lucene 8.11.1.&lt;/p&gt;
&lt;p&gt;Apache Lucene is a high-performance, full-featured text search engine library written entirely in Java. It is a technology suitable for nearly any application that requires full-text search, especially cross-platform.&lt;/p&gt;
&lt;p&gt;This release contains one bug fix …&lt;/p&gt;</summary><content type="html">&lt;p&gt;The Lucene PMC is pleased to announce the release of Apache Lucene 8.11.1.&lt;/p&gt;
&lt;p&gt;Apache Lucene is a high-performance, full-featured text search engine library written entirely in Java. It is a technology suitable for nearly any application that requires full-text search, especially cross-platform.&lt;/p&gt;
&lt;p&gt;This release contains one bug fix. The release is available for immediate download at:&lt;/p&gt;
&lt;p&gt;&lt;a href="https://lucene.apache.org/core/downloads.html"&gt;https://lucene.apache.org/core/downloads.html&lt;/a&gt;&lt;/p&gt;
&lt;h3 id="lucene-8111-release-highlights"&gt;Lucene 8.11.1 Release Highlights:&lt;/h3&gt;
&lt;ul&gt;
&lt;li&gt;Log4j is upgraded to v2.16.0 to mitigate CVE-2021-44228 (for Luke users)&lt;/li&gt;
&lt;/ul&gt;</content><category term="core/news"></category></entry><entry><title>Apache Lucene™ 9.0.0 available</title><link href="/" rel="alternate"></link><published>2021-12-07T00:00:00+00:00</published><updated>2021-12-07T00:00:00+00:00</updated><author><name>Lucene Developers</name></author><id>tag:None,2021-12-07:/</id><summary type="html">&lt;p&gt;The Lucene PMC is pleased to announce the release of Apache Lucene 9.0.0.&lt;/p&gt;
&lt;p&gt;Apache Lucene is a high-performance, full-featured search engine library written entirely in Java. It is a technology suitable for nearly any application that requires structured search, full-text search, faceting, nearest-neighbor search across high-dimensionality vectors, spell …&lt;/p&gt;</summary><content type="html">&lt;p&gt;The Lucene PMC is pleased to announce the release of Apache Lucene 9.0.0.&lt;/p&gt;
&lt;p&gt;Apache Lucene is a high-performance, full-featured search engine library written entirely in Java. It is a technology suitable for nearly any application that requires structured search, full-text search, faceting, nearest-neighbor search across high-dimensionality vectors, spell correction or query suggestions.&lt;/p&gt;
&lt;p&gt;This release contains numerous bug fixes, optimizations, and improvements, some of which are highlighted below. The release is available for immediate download at:&lt;/p&gt;
&lt;p&gt;&lt;a href="https://lucene.apache.org/core/downloads.html"&gt;https://lucene.apache.org/core/downloads.html&lt;/a&gt;&lt;/p&gt;
&lt;h3 id="lucene-900-release-highlights"&gt;Lucene 9.0.0 Release Highlights:&lt;/h3&gt;
&lt;h4 id="system-requirements"&gt;System requirements&lt;/h4&gt;
&lt;ul&gt;
&lt;li&gt;Lucene 9.0 requires JDK 11 or newer&lt;/li&gt;
&lt;/ul&gt;
&lt;h4 id="new-features"&gt;New features&lt;/h4&gt;
&lt;ul&gt;
&lt;li&gt;Support for indexing high-dimensionality numeric vectors to perform nearest-neighbor search, using the Hierarchical Navigable Small World graph algorithm&lt;/li&gt;
&lt;li&gt;New Analyzers for Serbian, Nepali, and Tamil languages&lt;/li&gt;
&lt;li&gt;IME-friendly autosuggest for Japanese&lt;/li&gt;
&lt;li&gt;Snowball 2, adding Hindi, Indonesian, Nepali, Serbian, Tamil, and Yiddish stemmers&lt;/li&gt;
&lt;li&gt;New normalization/stemming for Swedish and Norwegian&lt;/li&gt;
&lt;/ul&gt;
&lt;h4 id="optimizations"&gt;Optimizations&lt;/h4&gt;
&lt;ul&gt;
&lt;li&gt;Up to 400% faster taxonomy faceting&lt;/li&gt;
&lt;li&gt;10-15% faster indexing of multi-dimensional points&lt;/li&gt;
&lt;li&gt;Several times faster sorting on fields that are indexed with points. This optimization used to be an opt-in in late 8.x releases and is now opt-out as of 9.0.&lt;/li&gt;
&lt;li&gt;ConcurrentMergeScheduler now assumes fast I/O, likely improving indexing speed in case where heuristics would incorrectly detect whether the system had modern I/O or not&lt;/li&gt;
&lt;li&gt;Encoding of postings lists changed from FOR-delta to PFOR-delta to save further disk space&lt;/li&gt;
&lt;/ul&gt;
&lt;h4 id="other"&gt;Other&lt;/h4&gt;
&lt;ul&gt;
&lt;li&gt;File formats have all been changed from big-endian order to little endian order&lt;/li&gt;
&lt;li&gt;Lucene 9 no longer has split packages. This required renaming some packages outside of the lucene-core JAR, so you will need to adjust some imports accordingly.&lt;/li&gt;
&lt;li&gt;Using Lucene 9 with the module system should be considered experimental. We expect to make progress on this in future 9.x releases.&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;Please read CHANGES.txt for a full list of new features and changes:&lt;/p&gt;
&lt;p&gt;&lt;a href="https://lucene.apache.org/core/9_0_0/changes/Changes.html"&gt;https://lucene.apache.org/core/9_0_0/changes/Changes.html&lt;/a&gt;&lt;/p&gt;</content><category term="core/news"></category></entry><entry><title>Apache Lucene™ 8.11.0 available</title><link href="/" rel="alternate"></link><published>2021-11-16T00:00:00+00:00</published><updated>2021-11-16T00:00:00+00:00</updated><author><name>Lucene Developers</name></author><id>tag:None,2021-11-16:/</id><summary type="html">&lt;p&gt;The Lucene PMC is pleased to announce the release of Apache Lucene 8.11.0.&lt;/p&gt;
&lt;p&gt;Apache Lucene is a high-performance, full-featured text search engine library written entirely in Java. It is a technology suitable for nearly any application that requires full-text search, especially cross-platform.&lt;/p&gt;
&lt;p&gt;This release contains numerous bug fixes …&lt;/p&gt;</summary><content type="html">&lt;p&gt;The Lucene PMC is pleased to announce the release of Apache Lucene 8.11.0.&lt;/p&gt;
&lt;p&gt;Apache Lucene is a high-performance, full-featured text search engine library written entirely in Java. It is a technology suitable for nearly any application that requires full-text search, especially cross-platform.&lt;/p&gt;
&lt;p&gt;This release contains numerous bug fixes, optimizations, and improvements, some of which are highlighted below. The release is available for immediate download at:&lt;/p&gt;
&lt;p&gt;&lt;a href="https://lucene.apache.org/core/downloads.html"&gt;https://lucene.apache.org/core/downloads.html&lt;/a&gt;&lt;/p&gt;
&lt;h3 id="lucene-8110-release-highlights"&gt;Lucene 8.11.0 Release Highlights:&lt;/h3&gt;
&lt;ul&gt;
&lt;li&gt;Facets now properly ignore deleted documents when accumulating facet counts for all documents.&lt;/li&gt;
&lt;li&gt;CheckIndex can run concurrently.&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;Please read CHANGES.txt for a full list of new features and changes:&lt;/p&gt;
&lt;p&gt;&lt;a href="https://lucene.apache.org/core/8_11_0/changes/Changes.html"&gt;https://lucene.apache.org/core/8_11_0/changes/Changes.html&lt;/a&gt;&lt;/p&gt;</content><category term="core/news"></category></entry><entry><title>Apache Lucene™ 8.10.1 available</title><link href="/" rel="alternate"></link><published>2021-10-18T00:00:00+00:00</published><updated>2021-10-18T00:00:00+00:00</updated><author><name>Lucene Developers</name></author><id>tag:None,2021-10-18:/</id><summary type="html">&lt;p&gt;The Lucene PMC is pleased to announce the release of Apache Lucene 8.10.1.&lt;/p&gt;
&lt;p&gt;Apache Lucene is a high-performance, full-featured text search engine library written entirely in Java. It is a technology suitable for nearly any application that requires full-text search, especially cross-platform.&lt;/p&gt;
&lt;p&gt;This release contains bug fixes. The …&lt;/p&gt;</summary><content type="html">&lt;p&gt;The Lucene PMC is pleased to announce the release of Apache Lucene 8.10.1.&lt;/p&gt;
&lt;p&gt;Apache Lucene is a high-performance, full-featured text search engine library written entirely in Java. It is a technology suitable for nearly any application that requires full-text search, especially cross-platform.&lt;/p&gt;
&lt;p&gt;This release contains bug fixes. The release is available for immediate download at:&lt;/p&gt;
&lt;p&gt;&lt;a href="https://lucene.apache.org/core/downloads.html"&gt;https://lucene.apache.org/core/downloads.html&lt;/a&gt;&lt;/p&gt;
&lt;h3 id="lucene-8101-release-highlights"&gt;Lucene 8.10.1 Release Highlights:&lt;/h3&gt;
&lt;h4 id="bug-fixes"&gt;Bug fixes&lt;/h4&gt;
&lt;ul&gt;
&lt;li&gt;MultiCollector now handles single leaf collector that wants to skip low-scoring hits but the combined score mode doesn't allow it.&lt;/li&gt;
&lt;li&gt;Fix for sort optimization with search_after that was wrongly skipping document whose values are equal to the last value of the previous page.&lt;/li&gt;
&lt;li&gt;Fix for sort optimization with a chunked bulk scorer that was wrongly skipping documents.&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;Please read CHANGES.txt for a full list of changes:&lt;/p&gt;
&lt;p&gt;&lt;a href="https://lucene.apache.org/core/8_10_1/changes/Changes.html"&gt;https://lucene.apache.org/core/8_10_1/changes/Changes.html&lt;/a&gt;&lt;/p&gt;</content><category term="core/news"></category></entry><entry><title>Apache Lucene™ 8.10.0 available</title><link href="/" rel="alternate"></link><published>2021-09-27T00:00:00+00:00</published><updated>2021-09-27T00:00:00+00:00</updated><author><name>Lucene Developers</name></author><id>tag:None,2021-09-27:/</id><summary type="html">&lt;p&gt;The Lucene PMC is pleased to announce the release of Apache Lucene 8.10.0.&lt;/p&gt;
&lt;p&gt;Apache Lucene is a high-performance, full-featured text search engine library written entirely in Java. It is a technology suitable for nearly any application that requires full-text search, especially cross-platform.&lt;/p&gt;
&lt;p&gt;This release contains numerous bug fixes …&lt;/p&gt;</summary><content type="html">&lt;p&gt;The Lucene PMC is pleased to announce the release of Apache Lucene 8.10.0.&lt;/p&gt;
&lt;p&gt;Apache Lucene is a high-performance, full-featured text search engine library written entirely in Java. It is a technology suitable for nearly any application that requires full-text search, especially cross-platform.&lt;/p&gt;
&lt;p&gt;This release contains numerous bug fixes, optimizations, and improvements, some of which are highlighted below. The release is available for immediate download at:&lt;/p&gt;
&lt;p&gt;&lt;a href="https://lucene.apache.org/core/downloads.html"&gt;https://lucene.apache.org/core/downloads.html&lt;/a&gt;&lt;/p&gt;
&lt;h3 id="lucene-8100-release-highlights"&gt;Lucene 8.10.0 Release Highlights:&lt;/h3&gt;
&lt;h4 id="new-features"&gt;New features&lt;/h4&gt;
&lt;ul&gt;
&lt;li&gt;Multi-valued fields are now supported in numeric range facet counting&lt;/li&gt;
&lt;li&gt;Added new analyzer for Telugu&lt;/li&gt;
&lt;li&gt;Near-real-time readers opened from an IndexCommit can now sort their leaves&lt;/li&gt;
&lt;li&gt;SimpleText codec now implements skipping for its postings lists&lt;/li&gt;
&lt;/ul&gt;
&lt;h4 id="optimizations"&gt;Optimizations&lt;/h4&gt;
&lt;ul&gt;
&lt;li&gt;Performance improvements for faceting, including a new protected API to control which fields are counted for drill-down during drill sideways, and optimized drill sideways iterating&lt;/li&gt;
&lt;li&gt;RegexpQuery's detection of adversarial (ReDoS) regular expressions is improved, catching exotic cases that it missed before, and throwing TooComplexToDeterminizeException&lt;/li&gt;
&lt;li&gt;Speedup for computing the leading prefix and trailing suffix from an Automaton, and for managing powersets during determinize&lt;/li&gt;
&lt;li&gt;Speedups for stored fields retrieval with the default codec (BEST_SPEED)&lt;/li&gt;
&lt;li&gt;IndexWriter uses less RAM when buffering documents, especially in the case of many unique fields&lt;/li&gt;
&lt;li&gt;forceMerge will now merge any number of segments at once, making it much faster in many cases&lt;/li&gt;
&lt;li&gt;Compression improvements for docvalues storage&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;... plus a number of exciting bug fixes!&lt;/p&gt;
&lt;p&gt;Please read CHANGES.txt for a full list of new features and changes:&lt;/p&gt;
&lt;p&gt;&lt;a href="https://lucene.apache.org/core/8_10_0/changes/Changes.html"&gt;https://lucene.apache.org/core/8_10_0/changes/Changes.html&lt;/a&gt;&lt;/p&gt;</content><category term="core/news"></category></entry><entry><title>Apache Lucene™ 8.9.0 available</title><link href="/" rel="alternate"></link><published>2021-06-16T00:00:00+00:00</published><updated>2021-06-16T00:00:00+00:00</updated><author><name>Lucene Developers</name></author><id>tag:None,2021-06-16:/</id><summary type="html">&lt;p&gt;The Lucene PMC is pleased to announce the release of Apache Lucene 8.9.0.&lt;/p&gt;
&lt;p&gt;Apache Lucene is a high-performance, full-featured text search engine library written entirely in Java. It is a technology suitable for nearly any application that requires full-text search, especially cross-platform.&lt;/p&gt;
&lt;p&gt;This release contains numerous bug fixes …&lt;/p&gt;</summary><content type="html">&lt;p&gt;The Lucene PMC is pleased to announce the release of Apache Lucene 8.9.0.&lt;/p&gt;
&lt;p&gt;Apache Lucene is a high-performance, full-featured text search engine library written entirely in Java. It is a technology suitable for nearly any application that requires full-text search, especially cross-platform.&lt;/p&gt;
&lt;p&gt;This release contains numerous bug fixes, optimizations, and improvements, some of which are highlighted below. The release is available for immediate download at:&lt;/p&gt;
&lt;p&gt;&lt;a href="https://lucene.apache.org/core/downloads.html"&gt;https://lucene.apache.org/core/downloads.html&lt;/a&gt;&lt;/p&gt;
&lt;h3 id="lucene-890-release-highlights"&gt;Lucene 8.9.0 Release Highlights:&lt;/h3&gt;
&lt;ul&gt;
&lt;li&gt;Compression was added to SortedSet DocValues, which allowed to significantly reduce their size on disk.&lt;/li&gt;
&lt;li&gt;BM25FQuery was extended to handle similarities beyond BM25Similarity. It was renamed to CombinedFieldQuery to reflect its more general scope.&lt;/li&gt;
&lt;li&gt;A new PatternTypingFilter was added to allow setting a type attribute on tokens based on a configured set of regular expressions.&lt;/li&gt;
&lt;li&gt;An option was added to supply a custom leaf sorter for IndexWriter and DirectoryReader, which allows to speed up sort queries with a provided sort criteria.&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;Please read CHANGES.txt for a full list of new features and changes:&lt;/p&gt;
&lt;p&gt;&lt;a href="https://lucene.apache.org/core/8_9_0/changes/Changes.html"&gt;https://lucene.apache.org/core/8_9_0/changes/Changes.html&lt;/a&gt;&lt;/p&gt;</content><category term="core/news"></category></entry><entry><title>Apache Lucene™ 8.8.2 available</title><link href="/" rel="alternate"></link><published>2021-04-12T00:00:00+00:00</published><updated>2021-04-12T00:00:00+00:00</updated><author><name>Lucene Developers</name></author><id>tag:None,2021-04-12:/</id><summary type="html">&lt;p&gt;The Lucene PMC is pleased to announce the release of Apache Lucene 8.8.2.&lt;/p&gt;
&lt;p&gt;Apache Lucene is a high-performance, full-featured text search engine library written entirely in Java. It is a technology suitable for nearly any application that requires full-text search, especially cross-platform.&lt;/p&gt;
&lt;p&gt;This release contains three bug fixes …&lt;/p&gt;</summary><content type="html">&lt;p&gt;The Lucene PMC is pleased to announce the release of Apache Lucene 8.8.2.&lt;/p&gt;
&lt;p&gt;Apache Lucene is a high-performance, full-featured text search engine library written entirely in Java. It is a technology suitable for nearly any application that requires full-text search, especially cross-platform.&lt;/p&gt;
&lt;p&gt;This release contains three bug fixes. The release is available for immediate download at:&lt;/p&gt;
&lt;p&gt;&lt;a href="https://lucene.apache.org/core/downloads.html"&gt;https://lucene.apache.org/core/downloads.html&lt;/a&gt;&lt;/p&gt;
&lt;h3 id="lucene-882-release-highlights"&gt;Lucene 8.8.2 Release Highlights:&lt;/h3&gt;
&lt;ul&gt;
&lt;li&gt;LUCENE-9870: Fix Circle2D intersectsLine t-value (distance) range clamp&lt;/li&gt;
&lt;li&gt;LUCENE-9744: NPE on a degenerate query in MinimumShouldMatchIntervalsSource$MinimumMatchesIterator.getSubMatches().&lt;/li&gt;
&lt;li&gt;LUCENE-9762: DoubleValuesSource.fromQuery (also used by FunctionScoreQuery.boostByQuery) could throw an exception when the query implements TwoPhaseIterator and when the score is requested repeatedly&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;Please read CHANGES.txt for a full list of changes:&lt;/p&gt;
&lt;p&gt;&lt;a href="https://lucene.apache.org/core/8_8_2/changes/Changes.html"&gt;https://lucene.apache.org/core/8_8_2/changes/Changes.html&lt;/a&gt;&lt;/p&gt;</content><category term="core/news"></category></entry><entry><title>Apache Lucene™ 8.8.1 available</title><link href="/" rel="alternate"></link><published>2021-02-22T00:00:00+00:00</published><updated>2021-02-22T00:00:00+00:00</updated><author><name>Lucene Developers</name></author><id>tag:None,2021-02-22:/</id><summary type="html">&lt;p&gt;The Lucene PMC is pleased to announce the release of Apache Lucene 8.8.1.&lt;/p&gt;
&lt;p&gt;Apache Lucene is a high-performance, full-featured text search engine library written entirely in Java. It is a technology suitable for nearly any application that requires full-text search, especially cross-platform.&lt;/p&gt;
&lt;p&gt;This release contains numerous bug fixes …&lt;/p&gt;</summary><content type="html">&lt;p&gt;The Lucene PMC is pleased to announce the release of Apache Lucene 8.8.1.&lt;/p&gt;
&lt;p&gt;Apache Lucene is a high-performance, full-featured text search engine library written entirely in Java. It is a technology suitable for nearly any application that requires full-text search, especially cross-platform.&lt;/p&gt;
&lt;p&gt;This release contains numerous bug fixes, optimizations, and improvements, some of which are highlighted below. The release is available for immediate download at:&lt;/p&gt;
&lt;p&gt;&lt;a href="https://lucene.apache.org/core/downloads.html"&gt;https://lucene.apache.org/core/downloads.html&lt;/a&gt;&lt;/p&gt;
&lt;h3 id="lucene-881-release-highlights"&gt;Lucene 8.8.1 Release Highlights:&lt;/h3&gt;
&lt;p&gt;No changes from 8.8.0&lt;/p&gt;
&lt;p&gt;Please read CHANGES.txt for a full list of changes:&lt;/p&gt;
&lt;p&gt;&lt;a href="https://lucene.apache.org/core/8_8_1/changes/Changes.html"&gt;https://lucene.apache.org/core/8_8_1/changes/Changes.html&lt;/a&gt;&lt;/p&gt;</content><category term="core/news"></category></entry><entry><title>Apache Lucene™ 8.8.0 available</title><link href="/" rel="alternate"></link><published>2021-01-29T00:00:00+00:00</published><updated>2021-01-29T00:00:00+00:00</updated><author><name>Lucene Developers</name></author><id>tag:None,2021-01-29:/</id><summary type="html">&lt;p&gt;29/01/2021, Apache Lucene™ 8.8 available
The Lucene PMC is pleased to announce the release of Apache Lucene 8.8&lt;/p&gt;
&lt;p&gt;Apache Lucene is a high-performance, full-featured text search engine library written entirely in Java. It is a technology suitable for nearly any application that requires full-text search, especially …&lt;/p&gt;</summary><content type="html">&lt;p&gt;29/01/2021, Apache Lucene™ 8.8 available
The Lucene PMC is pleased to announce the release of Apache Lucene 8.8&lt;/p&gt;
&lt;p&gt;Apache Lucene is a high-performance, full-featured text search engine library written entirely in Java. It is a technology suitable for nearly any application that requires full-text search, especially cross-platform.&lt;/p&gt;
&lt;p&gt;This release contains numerous bug fixes, optimizations, and improvements, some of which are highlighted below. The release is available for immediate download at:&lt;/p&gt;
&lt;p&gt;&lt;a href="http://lucene.apache.org/core/mirrors-core-latest-redir.html"&gt;http://lucene.apache.org/core/mirrors-core-latest-redir.html&lt;/a&gt;&lt;/p&gt;
&lt;p&gt;Lucene 8.8 Release Highlights:
LatLonPoint query that accepts an array of LatLonGeometries, support for spatial relationships, &lt;/p&gt;
&lt;p&gt;XYPoint query that accepts an array of XYGeometries&lt;/p&gt;
&lt;p&gt;Doc values now allow configuring how to trade compression for retrieval speed&lt;/p&gt;
&lt;p&gt;Further details of changes are available in the change log available at:
&lt;a href="http://lucene.apache.org/core/8_8_0/changes/Changes.html"&gt;http://lucene.apache.org/core/8_8_0/changes/Changes.html&lt;/a&gt;&lt;/p&gt;
&lt;p&gt;Please report any feedback to the mailing lists:&lt;/p&gt;
&lt;p&gt;&lt;a href="http://lucene.apache.org/core/discussion.html"&gt;http://lucene.apache.org/core/discussion.html&lt;/a&gt;&lt;/p&gt;
&lt;p&gt;Note: The Apache Software Foundation uses an extensive mirroring network for distributing releases. It is possible that the mirror you are using may not have replicated the release yet. If that is the case, please try another mirror. This also applies to Maven access.&lt;/p&gt;</content><category term="core/news"></category></entry><entry><title>Apache Lucene™ 8.7.0 available</title><link href="/" rel="alternate"></link><published>2020-11-03T00:00:00+00:00</published><updated>2020-11-03T00:00:00+00:00</updated><author><name>Lucene Developers</name></author><id>tag:None,2020-11-03:/</id><summary type="html">&lt;p&gt;03/11/2020, Apache Lucene™ 8.7 available
The Lucene PMC is pleased to announce the release of Apache Lucene 8.7.&lt;/p&gt;
&lt;p&gt;Apache Lucene is a high-performance, full-featured text search engine library written entirely in Java. It is a technology suitable for nearly any application that requires full-text search, especially …&lt;/p&gt;</summary><content type="html">&lt;p&gt;03/11/2020, Apache Lucene™ 8.7 available
The Lucene PMC is pleased to announce the release of Apache Lucene 8.7.&lt;/p&gt;
&lt;p&gt;Apache Lucene is a high-performance, full-featured text search engine library written entirely in Java. It is a technology suitable for nearly any application that requires full-text search, especially cross-platform.&lt;/p&gt;
&lt;p&gt;This release contains numerous bug fixes, optimizations, and improvements, some of which are highlighted below. The release is available for immediate download at:&lt;/p&gt;
&lt;p&gt;&lt;a href="http://lucene.apache.org/core/mirrors-core-latest-redir.html"&gt;http://lucene.apache.org/core/mirrors-core-latest-redir.html&lt;/a&gt;&lt;/p&gt;
&lt;p&gt;Lucene 8.7 Release Highlights:
Better compression of stored fields. Stored fields now use dictionaries in order to improve the compression ratio when there is a lot of redundancy across documents. This works for both the BEST_SPEED and the BEST_COMPRESSION modes.&lt;/p&gt;
&lt;p&gt;Faster sorting by field. When a doc-value field is also indexed with points, Lucene now takes advantage of this points index in order to skip documents whose sort value is not competitive.&lt;/p&gt;
&lt;p&gt;Faster flushing of stored fields when index sorting is enabled. This can significantly speed up indexing when a non-negligible amount of data is stored in the index and index sorting is enabled.&lt;/p&gt;
&lt;p&gt;Further details of changes are available in the change log available at:
&lt;a href="http://lucene.apache.org/core/8_7_0/changes/Changes.html"&gt;http://lucene.apache.org/core/8_7_0/changes/Changes.html&lt;/a&gt;&lt;/p&gt;
&lt;p&gt;Please report any feedback to the mailing lists:&lt;/p&gt;
&lt;p&gt;&lt;a href="http://lucene.apache.org/core/discussion.html"&gt;http://lucene.apache.org/core/discussion.html&lt;/a&gt;&lt;/p&gt;
&lt;p&gt;Note: The Apache Software Foundation uses an extensive mirroring network for distributing releases. It is possible that the mirror you are using may not have replicated the release yet. If that is the case, please try another mirror. This also applies to Maven access.&lt;/p&gt;</content><category term="core/news"></category></entry><entry><title>Apache Lucene™ 8.6.3 available</title><link href="/" rel="alternate"></link><published>2020-10-07T00:00:00+00:00</published><updated>2020-10-07T00:00:00+00:00</updated><author><name>Lucene Developers</name></author><id>tag:None,2020-10-07:/</id><summary type="html">&lt;p&gt;The Lucene PMC is pleased to announce the release of Apache Lucene 8.6.3.&lt;/p&gt;
&lt;p&gt;Apache Lucene is a high-performance, full-featured text search engine library written entirely in Java. It is a technology suitable for nearly any application that requires full-text search, especially cross-platform.&lt;/p&gt;
&lt;p&gt;This release contains no additional bug …&lt;/p&gt;</summary><content type="html">&lt;p&gt;The Lucene PMC is pleased to announce the release of Apache Lucene 8.6.3.&lt;/p&gt;
&lt;p&gt;Apache Lucene is a high-performance, full-featured text search engine library written entirely in Java. It is a technology suitable for nearly any application that requires full-text search, especially cross-platform.&lt;/p&gt;
&lt;p&gt;This release contains no additional bug fixes over the previous version 8.6.2. The release is available for immediate download at:&lt;/p&gt;
&lt;p&gt;&lt;a href="https://lucene.apache.org/core/downloads.html"&gt;https://lucene.apache.org/core/downloads.html&lt;/a&gt;&lt;/p&gt;</content><category term="core/news"></category></entry><entry><title>Apache Lucene™ 8.6.2 available</title><link href="/" rel="alternate"></link><published>2020-09-01T00:00:00+00:00</published><updated>2020-09-01T00:00:00+00:00</updated><author><name>Lucene Developers</name></author><id>tag:None,2020-09-01:/</id><summary type="html">&lt;p&gt;The Lucene PMC is pleased to announce the release of Apache Lucene 8.6.2.&lt;/p&gt;
&lt;p&gt;Apache Lucene is a high-performance, full-featured text search engine library written entirely in Java. It is a technology suitable for nearly any application that requires full-text search, especially cross-platform.&lt;/p&gt;
&lt;p&gt;This release contains one bug fix …&lt;/p&gt;</summary><content type="html">&lt;p&gt;The Lucene PMC is pleased to announce the release of Apache Lucene 8.6.2.&lt;/p&gt;
&lt;p&gt;Apache Lucene is a high-performance, full-featured text search engine library written entirely in Java. It is a technology suitable for nearly any application that requires full-text search, especially cross-platform.&lt;/p&gt;
&lt;p&gt;This release contains one bug fix. The release is available for immediate download at:&lt;/p&gt;
&lt;p&gt;&lt;a href="https://lucene.apache.org/core/downloads.html"&gt;https://lucene.apache.org/core/downloads.html&lt;/a&gt;&lt;/p&gt;
&lt;h3 id="lucene-862-bug-fixes"&gt;Lucene 8.6.2 Bug Fixes:&lt;/h3&gt;
&lt;ul&gt;
&lt;li&gt;LUCENE-9478: IndexWriter leaked about 500 byte of heap space for each full-flush, getReader or commit. This was a regression in 6.8.0&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;Please read CHANGES.txt for a full list of changes:&lt;/p&gt;
&lt;p&gt;&lt;a href="https://lucene.apache.org/core/8_6_2/changes/Changes.html"&gt;https://lucene.apache.org/core/8_6_2/changes/Changes.html&lt;/a&gt;&lt;/p&gt;</content><category term="core/news"></category></entry><entry><title>Apache Lucene™ 8.6.1 available</title><link href="/" rel="alternate"></link><published>2020-08-13T00:00:00+00:00</published><updated>2020-08-13T00:00:00+00:00</updated><author><name>Lucene Developers</name></author><id>tag:None,2020-08-13:/</id><summary type="html">&lt;p&gt;The Lucene PMC is pleased to announce the release of Apache Lucene 8.6.1.&lt;/p&gt;
&lt;p&gt;Apache Lucene is a high-performance, full-featured text search engine library written entirely in Java. It is a technology suitable for nearly any application that requires full-text search, especially cross-platform.&lt;/p&gt;
&lt;p&gt;This release contains numerous bug fixes …&lt;/p&gt;</summary><content type="html">&lt;p&gt;The Lucene PMC is pleased to announce the release of Apache Lucene 8.6.1.&lt;/p&gt;
&lt;p&gt;Apache Lucene is a high-performance, full-featured text search engine library written entirely in Java. It is a technology suitable for nearly any application that requires full-text search, especially cross-platform.&lt;/p&gt;
&lt;p&gt;This release contains numerous bug fixes, optimizations, and improvements, some of which are highlighted below. The release is available for immediate download at:&lt;/p&gt;
&lt;p&gt;&lt;a href="https://lucene.apache.org/core/downloads.html"&gt;https://lucene.apache.org/core/downloads.html&lt;/a&gt;&lt;/p&gt;
&lt;h3 id="lucene-861-release-highlights"&gt;Lucene 8.6.1 Release Highlights:&lt;/h3&gt;
&lt;ul&gt;
&lt;li&gt;LUCENE-9443: The UnifiedHighlighter was closing the underlying reader when there were multiple term-vector fields.&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;Please read CHANGES.txt for a full list of changes:&lt;/p&gt;
&lt;p&gt;&lt;a href="https://lucene.apache.org/core/8_6_1/changes/Changes.html"&gt;https://lucene.apache.org/core/8_6_1/changes/Changes.html&lt;/a&gt;&lt;/p&gt;</content><category term="core/news"></category></entry><entry><title>Apache Lucene™ 8.6.0 available</title><link href="/" rel="alternate"></link><published>2020-07-15T00:00:00+00:00</published><updated>2020-07-15T00:00:00+00:00</updated><author><name>Lucene Developers</name></author><id>tag:None,2020-07-15:/</id><summary type="html">&lt;p&gt;The Lucene PMC is pleased to announce the release of Apache Lucene 8.6.0.&lt;/p&gt;
&lt;p&gt;Apache Lucene is a high-performance, full-featured text search engine library written entirely in Java. It is a technology suitable for nearly any application that requires full-text search, especially cross-platform.&lt;/p&gt;
&lt;p&gt;This release contains numerous bug fixes …&lt;/p&gt;</summary><content type="html">&lt;p&gt;The Lucene PMC is pleased to announce the release of Apache Lucene 8.6.0.&lt;/p&gt;
&lt;p&gt;Apache Lucene is a high-performance, full-featured text search engine library written entirely in Java. It is a technology suitable for nearly any application that requires full-text search, especially cross-platform.&lt;/p&gt;
&lt;p&gt;This release contains numerous bug fixes, optimizations, and improvements, some of which are highlighted below. The release is available for immediate download at:&lt;/p&gt;
&lt;p&gt;&lt;a href="https://lucene.apache.org/core/downloads.html"&gt;https://lucene.apache.org/core/downloads.html&lt;/a&gt;&lt;/p&gt;
&lt;h3 id="lucene-860-release-highlights"&gt;Lucene 8.6.0 Release Highlights:&lt;/h3&gt;
&lt;ul&gt;
&lt;li&gt;API change in: SimpleFSDireectory, IndexWriterConfig, MergeScheduler, SortFields, SimpleBindings, QueryVisitor, DocValues, CodecUtil.&lt;/li&gt;
&lt;li&gt;New: IndexWriter merge-on-commit feature to selectively merge small segments on commit, subject to a configurable timeout, to improve search performance by reducing the number of small segments for searching.&lt;/li&gt;
&lt;li&gt;New: Grouping by range based on DoubleValueSource and LongValueSource.&lt;/li&gt;
&lt;li&gt;Optimizations: BKD trees and index, DoubleValuesSource/QueryValueSource, UsageTrackingQueryingCachingPolicy, FST, Geometry queries, Points, UniformSplit.&lt;/li&gt;
&lt;li&gt;Others: Ukrainian analyzer, checksums verification, resource leaks fixes.&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;Please read CHANGES.txt for a full list of new features and changes:&lt;/p&gt;
&lt;p&gt;&lt;a href="https://lucene.apache.org/core/8_6_0/changes/Changes.html"&gt;https://lucene.apache.org/core/8_6_0/changes/Changes.html&lt;/a&gt;&lt;/p&gt;</content><category term="core/news"></category></entry><entry><title>Apache Lucene™ 8.5.2 available</title><link href="/" rel="alternate"></link><published>2020-05-26T00:00:00+00:00</published><updated>2020-05-26T00:00:00+00:00</updated><author><name>Lucene Developers</name></author><id>tag:None,2020-05-26:/</id><summary type="html">&lt;p&gt;The Lucene PMC is pleased to announce the release of Apache Lucene 8.5.2.&lt;/p&gt;
&lt;p&gt;Apache Lucene is a high-performance, full-featured text search engine library written entirely in Java. It is a technology suitable for nearly any application that requires full-text search, especially cross-platform.&lt;/p&gt;
&lt;p&gt;This release contains one bug fixes …&lt;/p&gt;</summary><content type="html">&lt;p&gt;The Lucene PMC is pleased to announce the release of Apache Lucene 8.5.2.&lt;/p&gt;
&lt;p&gt;Apache Lucene is a high-performance, full-featured text search engine library written entirely in Java. It is a technology suitable for nearly any application that requires full-text search, especially cross-platform.&lt;/p&gt;
&lt;p&gt;This release contains one bug fixes. The release is available for immediate download at:&lt;/p&gt;
&lt;p&gt;&lt;a href="https://lucene.apache.org/core/downloads.html"&gt;https://lucene.apache.org/core/downloads.html&lt;/a&gt;&lt;/p&gt;
&lt;h3 id="lucene-852-release-highlights"&gt;Lucene 8.5.2 Release Highlights:&lt;/h3&gt;
&lt;ul&gt;
&lt;li&gt;LUCENE-9350: Don't cache automata on FuzzyQuery&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;Please read CHANGES.txt for a full list of changes:&lt;/p&gt;
&lt;p&gt;&lt;a href="https://lucene.apache.org/core/8_5_2/changes/Changes.html"&gt;https://lucene.apache.org/core/8_5_2/changes/Changes.html&lt;/a&gt;&lt;/p&gt;</content><category term="core/news"></category></entry><entry><title>Apache Lucene™ 7.7.3 available</title><link href="/" rel="alternate"></link><published>2020-04-28T00:00:00+00:00</published><updated>2020-04-28T00:00:00+00:00</updated><author><name>Lucene Developers</name></author><id>tag:None,2020-04-28:/</id><summary type="html">&lt;p&gt;The Lucene PMC is pleased to announce the release of Apache Lucene 7.7.3.&lt;/p&gt;
&lt;p&gt;Apache Lucene is a high-performance, full-featured text search engine library written entirely in Java. It is a technology suitable for nearly any application that requires full-text search, especially cross-platform.&lt;/p&gt;
&lt;p&gt;This release contains 1 bugfix in …&lt;/p&gt;</summary><content type="html">&lt;p&gt;The Lucene PMC is pleased to announce the release of Apache Lucene 7.7.3.&lt;/p&gt;
&lt;p&gt;Apache Lucene is a high-performance, full-featured text search engine library written entirely in Java. It is a technology suitable for nearly any application that requires full-text search, especially cross-platform.&lt;/p&gt;
&lt;p&gt;This release contains 1 bugfix in Lucene. The release is available for immediate download at:&lt;/p&gt;
&lt;p&gt;&lt;a href="https://lucene.apache.org/core/downloads.html"&gt;https://lucene.apache.org/core/downloads.html&lt;/a&gt;&lt;/p&gt;
&lt;p&gt;Please read CHANGES.txt for a full list of changes:&lt;/p&gt;
&lt;p&gt;&lt;a href="https://lucene.apache.org/core/7_7_3/changes/Changes.html"&gt;https://lucene.apache.org/core/7_7_3/changes/Changes.html&lt;/a&gt;&lt;/p&gt;</content><category term="core/news"></category></entry><entry><title>Apache Lucene™ 8.5.1 available</title><link href="/" rel="alternate"></link><published>2020-04-16T00:00:00+00:00</published><updated>2020-04-16T00:00:00+00:00</updated><author><name>Lucene Developers</name></author><id>tag:None,2020-04-16:/</id><summary type="html">&lt;p&gt;The Lucene PMC is pleased to announce the release of Apache Lucene 8.5.1.&lt;/p&gt;
&lt;p&gt;Apache Lucene is a high-performance, full-featured text search engine library written entirely in Java. It is a technology suitable for nearly any application that requires full-text search, especially cross-platform.&lt;/p&gt;
&lt;p&gt;This release contains one bug fix …&lt;/p&gt;</summary><content type="html">&lt;p&gt;The Lucene PMC is pleased to announce the release of Apache Lucene 8.5.1.&lt;/p&gt;
&lt;p&gt;Apache Lucene is a high-performance, full-featured text search engine library written entirely in Java. It is a technology suitable for nearly any application that requires full-text search, especially cross-platform.&lt;/p&gt;
&lt;p&gt;This release contains one bug fix. The release is available for immediate download at:&lt;/p&gt;
&lt;p&gt;&lt;a href="https://lucene.apache.org/core/downloads.html"&gt;https://lucene.apache.org/core/downloads.html&lt;/a&gt;&lt;/p&gt;
&lt;p&gt;Lucene 8.5.1 Bug Fixes:&lt;/p&gt;
&lt;p&gt;LUCENE-9300: Index corruption with doc values updates and addIndexes.&lt;/p&gt;
&lt;p&gt;Further details of changes are available in the change log available at: &lt;/p&gt;
&lt;p&gt;&lt;a href="https://lucene.apache.org/core/8_5_1/changes/Changes.html"&gt;https://lucene.apache.org/core/8_5_1/changes/Changes.html&lt;/a&gt;&lt;/p&gt;</content><category term="core/news"></category></entry><entry><title>Apache Lucene™ 8.5.0 available</title><link href="/" rel="alternate"></link><published>2020-03-24T00:00:00+00:00</published><updated>2020-03-24T00:00:00+00:00</updated><author><name>Lucene Developers</name></author><id>tag:None,2020-03-24:/</id><summary type="html">&lt;p&gt;The Lucene PMC is pleased to announce the release of Apache Lucene 8.5.0.&lt;/p&gt;
&lt;p&gt;Apache Lucene is a high-performance, full-featured text search engine library written entirely in Java. It is a technology suitable for nearly any application that requires full-text search, especially cross-platform.&lt;/p&gt;
&lt;p&gt;This release contains numerous bug fixes …&lt;/p&gt;</summary><content type="html">&lt;p&gt;The Lucene PMC is pleased to announce the release of Apache Lucene 8.5.0.&lt;/p&gt;
&lt;p&gt;Apache Lucene is a high-performance, full-featured text search engine library written entirely in Java. It is a technology suitable for nearly any application that requires full-text search, especially cross-platform.&lt;/p&gt;
&lt;p&gt;This release contains numerous bug fixes, optimizations, and improvements, some of which are highlighted below. The release is available for immediate download at:&lt;/p&gt;
&lt;p&gt;&lt;a href="https://lucene.apache.org/core/downloads.html"&gt;https://lucene.apache.org/core/downloads.html&lt;/a&gt;&lt;/p&gt;
&lt;h3 id="lucene-850-release-highlights"&gt;Lucene 8.5.0 Release Highlights:&lt;/h3&gt;
&lt;ul&gt;
&lt;li&gt;XYPointField allows you to index points in flat X,Y space and efficiently find documents that fall within a bounding box, distance or arbitrary polygon&lt;/li&gt;
&lt;li&gt;New query builders on LatLonShape allow you to efficiently find documents with a specific relation to a point or polygon&lt;/li&gt;
&lt;li&gt;You can now store up to 16 data dimensions in a Point field&lt;/li&gt;
&lt;li&gt;KoreanTokenizer supports custom dictionaries&lt;/li&gt;
&lt;li&gt;Binary doc values are now compressed, and term dictionaries have improved compression&lt;/li&gt;
&lt;li&gt;Index flushes are up to 20% faster if all docvalues updates are updating a single field to the same value&lt;/li&gt;
&lt;li&gt;The index of stored fields and term vectors is now stored off-heap&lt;/li&gt;
&lt;li&gt;Query parsers based on QueryBuilder can boost particular terms or synonyms by setting BoostAttribute values on a token stream&lt;/li&gt;
&lt;li&gt;Intervals queries correctly handle repeated subterms in ordered and unordered sources&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;Please read CHANGES.txt for a full list of new features and changes:&lt;/p&gt;
&lt;p&gt;&lt;a href="https://lucene.apache.org/core/8_5_0/changes/Changes.html"&gt;https://lucene.apache.org/core/8_5_0/changes/Changes.html&lt;/a&gt;&lt;/p&gt;</content><category term="core/news"></category></entry><entry><title>Apache Lucene™ 8.4.1 available</title><link href="/" rel="alternate"></link><published>2020-01-13T00:00:00+00:00</published><updated>2020-01-13T00:00:00+00:00</updated><author><name>Lucene Developers</name></author><id>tag:None,2020-01-13:/</id><summary type="html">&lt;p&gt;The Lucene PMC is pleased to announce the release of Apache Lucene 8.4.1.&lt;/p&gt;
&lt;p&gt;Apache Lucene is a high-performance, full-featured text search engine library written entirely in Java. It is a technology suitable for nearly any application that requires full-text search, especially cross-platform.&lt;/p&gt;
&lt;p&gt;This release contains numerous bug fixes …&lt;/p&gt;</summary><content type="html">&lt;p&gt;The Lucene PMC is pleased to announce the release of Apache Lucene 8.4.1.&lt;/p&gt;
&lt;p&gt;Apache Lucene is a high-performance, full-featured text search engine library written entirely in Java. It is a technology suitable for nearly any application that requires full-text search, especially cross-platform.&lt;/p&gt;
&lt;p&gt;This release contains numerous bug fixes, optimizations, and improvements, some of which are highlighted below. The release is available for immediate download at:&lt;/p&gt;
&lt;p&gt;&lt;a href="https://lucene.apache.org/core/downloads.html"&gt;https://lucene.apache.org/core/downloads.html&lt;/a&gt;&lt;/p&gt;
&lt;h3 id="lucene-841-release-highlights"&gt;Lucene 8.4.1 Release Highlights:&lt;/h3&gt;
&lt;p&gt;(No Changes since 8.4.0)&lt;/p&gt;</content><category term="core/news"></category></entry><entry><title>Apache Lucene™ 8.4.0 available</title><link href="/" rel="alternate"></link><published>2019-12-29T00:00:00+00:00</published><updated>2019-12-29T00:00:00+00:00</updated><author><name>Lucene Developers</name></author><id>tag:None,2019-12-29:/</id><summary type="html">&lt;p&gt;The Lucene PMC is pleased to announce the release of Apache Lucene 8.4.0.&lt;/p&gt;
&lt;p&gt;Apache Lucene is a high-performance, full-featured text search engine library written entirely in Java. It is a technology suitable for nearly any application that requires full-text search, especially cross-platform.&lt;/p&gt;
&lt;p&gt;This release contains numerous bug fixes …&lt;/p&gt;</summary><content type="html">&lt;p&gt;The Lucene PMC is pleased to announce the release of Apache Lucene 8.4.0.&lt;/p&gt;
&lt;p&gt;Apache Lucene is a high-performance, full-featured text search engine library written entirely in Java. It is a technology suitable for nearly any application that requires full-text search, especially cross-platform.&lt;/p&gt;
&lt;p&gt;This release contains numerous bug fixes, optimizations, and improvements, some of which are highlighted below. The release is available for immediate download at:&lt;/p&gt;
&lt;p&gt;&lt;a href="https://lucene.apache.org/core/downloads.html"&gt;https://lucene.apache.org/core/downloads.html&lt;/a&gt;&lt;/p&gt;
&lt;h3 id="lucene-840-release-highlights"&gt;Lucene 8.4.0 Release Highlights:&lt;/h3&gt;
&lt;ul&gt;
&lt;li&gt;LatLonShape now supports the "CONTAINS" relation, which enables to find all indexed shapes that contain the query shape.&lt;/li&gt;
&lt;li&gt;Concurrent search is getting more efficient by allowing collectors to share information across threads in order to more efficiently skip non-competitive hits.&lt;/li&gt;
&lt;li&gt;Faster FST lookups on dense nodes.&lt;/li&gt;
&lt;li&gt;Postings are now decoded using SIMD instructions.&lt;/li&gt;
&lt;li&gt;LRUQueryCache includes new heuristics that prevent caching from hurting latency too much.&lt;/li&gt;
&lt;li&gt;LatLonShape builds a more efficient tree that is expected to translate into search speed improvements.&lt;/li&gt;
&lt;li&gt;BaseDirectoryReader no longer sums up document counts across leaves eagerly, allowing for more efficient reader views that hide a subset of documents.&lt;/li&gt;
&lt;li&gt;The index on top of BKD trees is now stored off-heap with MMapDirectory.&lt;/li&gt;
&lt;li&gt;Simple Intervals queries support highlighting.&lt;/li&gt;
&lt;li&gt;Reading DocValues can be interrupted when timeout is exceeded.&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;Please read CHANGES.txt for a full list of new features and changes:&lt;/p&gt;
&lt;p&gt;&lt;a href="https://lucene.apache.org/core/8_4_0/changes/Changes.html"&gt;https://lucene.apache.org/core/8_4_0/changes/Changes.html&lt;/a&gt;&lt;/p&gt;</content><category term="core/news"></category></entry><entry><title>Apache Lucene™ 8.3.1 available</title><link href="/" rel="alternate"></link><published>2019-12-03T00:00:00+00:00</published><updated>2019-12-03T00:00:00+00:00</updated><author><name>Lucene Developers</name></author><id>tag:None,2019-12-03:/</id><summary type="html">&lt;p&gt;The Lucene PMC is pleased to announce the release of Apache Lucene 8.3.1.&lt;/p&gt;
&lt;p&gt;Apache Lucene is a high-performance, full-featured text search engine library written entirely in Java. It is a technology suitable for nearly any application that requires full-text search, especially cross-platform.&lt;/p&gt;
&lt;p&gt;This release contains numerous bug fixes …&lt;/p&gt;</summary><content type="html">&lt;p&gt;The Lucene PMC is pleased to announce the release of Apache Lucene 8.3.1.&lt;/p&gt;
&lt;p&gt;Apache Lucene is a high-performance, full-featured text search engine library written entirely in Java. It is a technology suitable for nearly any application that requires full-text search, especially cross-platform.&lt;/p&gt;
&lt;p&gt;This release contains numerous bug fixes, optimizations, and improvements, some of which are highlighted below. The release is available for immediate download at:&lt;/p&gt;
&lt;p&gt;&lt;a href="https://lucene.apache.org/core/downloads.html"&gt;https://lucene.apache.org/core/downloads.html&lt;/a&gt;&lt;/p&gt;
&lt;h3 id="lucene-831-release-highlights"&gt;Lucene 8.3.1 Release Highlights:&lt;/h3&gt;
&lt;ul&gt;
&lt;li&gt;Bugfix: MultiTermIntervalsSource.visit() was not calling back to its visitor&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;Please read CHANGES.txt for a full list of changes:&lt;/p&gt;
&lt;p&gt;&lt;a href="https://lucene.apache.org/core/8_3_1/changes/Changes.html"&gt;https://lucene.apache.org/core/8_3_1/changes/Changes.html&lt;/a&gt;&lt;/p&gt;</content><category term="core/news"></category></entry><entry><title>Apache Lucene™ 8.3.0 available</title><link href="/" rel="alternate"></link><published>2019-11-02T00:00:00+00:00</published><updated>2019-11-02T00:00:00+00:00</updated><author><name>Lucene Developers</name></author><id>tag:None,2019-11-02:/</id><summary type="html">&lt;p&gt;The Lucene PMC is pleased to announce the release of Apache Lucene 8.3.0.&lt;/p&gt;
&lt;p&gt;Apache Lucene is a high-performance, full-featured text search engine library written entirely in Java. It is a technology suitable for nearly any application that requires full-text search, especially cross&lt;/p&gt;
&lt;p&gt;This release contains numerous bug fixes …&lt;/p&gt;</summary><content type="html">&lt;p&gt;The Lucene PMC is pleased to announce the release of Apache Lucene 8.3.0.&lt;/p&gt;
&lt;p&gt;Apache Lucene is a high-performance, full-featured text search engine library written entirely in Java. It is a technology suitable for nearly any application that requires full-text search, especially cross&lt;/p&gt;
&lt;p&gt;This release contains numerous bug fixes, optimizations, and improvements, some of which are highlighted below. The release is available for immediate download at:&lt;/p&gt;
&lt;p&gt;&lt;a href="https://lucene.apache.org/core/downloads.html"&gt;https://lucene.apache.org/core/downloads.html&lt;/a&gt;&lt;/p&gt;
&lt;h3 id="lucene-830-release-highlights"&gt;Lucene 8.3.0 Release Highlights:&lt;/h3&gt;
&lt;ul&gt;
&lt;li&gt;New SpanishMinimalStemFilter&lt;/li&gt;
&lt;li&gt;New "export all terms and doc freqs" feature to Luke with delimiters&lt;/li&gt;
&lt;li&gt;Composite Matches from multiple subqueries now allow access to their submatches, and a new NamedMatches API allows marking of subqueries and a simple way to find which subqueries have matched on a given&lt;/li&gt;
&lt;li&gt;Range Query For Multiple Connected Ranges&lt;/li&gt;
&lt;li&gt;LatLonDocValuesPointInPolygonQuery for LatLonDocValuesField&lt;/li&gt;
&lt;li&gt;New UniformSplitPostingsFormat (name "UniformSplit") primarily benefiting in simplicity and extensibility&lt;/li&gt;
&lt;li&gt;New STUniformSplitPostingsFormat (name "SharedTermsUniformSplit") that shares a single internal term dictionary across fields&lt;/li&gt;
&lt;li&gt;DisjunctionMaxQuery more efficiently leverages impacts to skip non-competitive hits&lt;/li&gt;
&lt;li&gt;BooleanQuery with no scoring clause can now early terminate the query when the total hits is not requested&lt;/li&gt;
&lt;li&gt;Matches on wildcard queries will defer building their full disjunction until a MatchesIterator is pulled&lt;/li&gt;
&lt;li&gt;spatial-extras quad and packed quad prefix trees now index points faster&lt;/li&gt;
&lt;li&gt;Add additional leaf node level optimizations in LatLonShapeBoundingBoxQuery&lt;/li&gt;
&lt;li&gt;Improve performance of WITHIN and DISJOINT queries for Shape queries by doing just one pass whenever possible&lt;/li&gt;
&lt;li&gt;Introduce shared count based early termination across multiple slices&lt;/li&gt;
&lt;li&gt;Blocktree's seekExact now short-circuits false if the term isn't in the min-max range of the segment. Large perf gain for ID/time like data when populated sequentially&lt;/li&gt;
&lt;li&gt;Show SPI names instead of class names in Luke Analysis tab&lt;/li&gt;
&lt;li&gt;GraphTokenStreamFiniteStrings preserves all Token attributes through its finite strings TokenStreams&lt;/li&gt;
&lt;li&gt;Introduced SpanPositionRange into XML Query Parser&lt;/li&gt;
&lt;li&gt;Use a sort key instead of true distance in NearestNeighbor&lt;/li&gt;
&lt;li&gt;Tessellator labels the edges of the generated triangles whether they belong to the original polygon&lt;/li&gt;
&lt;li&gt;Use exact distance between point and bounding rectangle in FloatPointNearestNeighbor&lt;/li&gt;
&lt;li&gt;The Korean analyzer now splits tokens on boundaries between digits and alphabetic characters&lt;/li&gt;
&lt;li&gt;MoreLikeThis is biased for uncommon fields&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;Please read CHANGES.txt for a full list of new features and changes:&lt;/p&gt;
&lt;p&gt;&lt;a href="https://lucene.apache.org/core/8_3_0/changes/Changes.html"&gt;https://lucene.apache.org/core/8_3_0/changes/Changes.html&lt;/a&gt;&lt;/p&gt;</content><category term="core/news"></category></entry><entry><title>Apache Lucene™ 8.2.0 available</title><link href="/" rel="alternate"></link><published>2019-07-26T00:00:00+00:00</published><updated>2019-07-26T00:00:00+00:00</updated><author><name>Lucene Developers</name></author><id>tag:None,2019-07-26:/</id><summary type="html">&lt;p&gt;The Lucene PMC is pleased to announce the release of Apache Lucene 8.2.0.&lt;/p&gt;
&lt;p&gt;Apache Lucene is a high-performance, full-featured text search engine library written entirely in Java. It is a technology suitable for nearly any application that requires full-text search, especially cross-platform.&lt;/p&gt;
&lt;p&gt;This release contains numerous bug fixes …&lt;/p&gt;</summary><content type="html">&lt;p&gt;The Lucene PMC is pleased to announce the release of Apache Lucene 8.2.0.&lt;/p&gt;
&lt;p&gt;Apache Lucene is a high-performance, full-featured text search engine library written entirely in Java. It is a technology suitable for nearly any application that requires full-text search, especially cross-platform.&lt;/p&gt;
&lt;p&gt;This release contains numerous bug fixes, optimizations, and improvements, some of which are highlighted below. The release is available for immediate download at:&lt;/p&gt;
&lt;p&gt;&lt;a href="https://lucene.apache.org/core/downloads.html"&gt;https://lucene.apache.org/core/downloads.html&lt;/a&gt;&lt;/p&gt;
&lt;h3 id="lucene-820-release-highlights"&gt;Lucene 8.2.0 Release Highlights:&lt;/h3&gt;
&lt;h4 id="api-changes"&gt;API Changes:&lt;/h4&gt;
&lt;ul&gt;
&lt;li&gt;Intervals queries has been moved from the sandbox to the queries module.&lt;/li&gt;
&lt;/ul&gt;
&lt;h4 id="new-features"&gt;New Features&lt;/h4&gt;
&lt;ul&gt;
&lt;li&gt;New XYShape Field and Queries for indexing and querying general cartesian geometries.&lt;/li&gt;
&lt;li&gt;Snowball stemmer/analyzer for the Estonian language.&lt;/li&gt;
&lt;li&gt;Provide a FeatureSortfield to allow sorting search hits by descending value of a feature.&lt;/li&gt;
&lt;li&gt;Add new KoreanNumberFilter that can change Hangul character to number and process decimal point.&lt;/li&gt;
&lt;li&gt;Add doc-value support to range fields.&lt;/li&gt;
&lt;li&gt;Add monitor subproject (previously Luwak monitoring library) that allows a stream of documents to be matched against a set of registered queriesin an efficient manner.&lt;/li&gt;
&lt;li&gt;Add a numeric range query in sandbox that takes advantage of index sorting.Add a numeric range query in sandbox that takes advantage of index sorting.&lt;/li&gt;
&lt;/ul&gt;
&lt;h4 id="optimizations"&gt;Optimizations&lt;/h4&gt;
&lt;ul&gt;
&lt;li&gt;Use exponential search instead of binary search in IntArrayDocIdSet#advance method.&lt;/li&gt;
&lt;li&gt;Use incoming thread for execution if IndexSearcher has an executor. Now caller threads execute at least one search on an index even if there is an executor provided to minimize thread context switching.&lt;/li&gt;
&lt;li&gt;New storing strategy for BKD tree leaves with low cardinality that can lower storage costs and It can be used at search time to speed up queries.&lt;/li&gt;
&lt;li&gt;Load frequencies lazily only when needed in BlockDocsEnum and BlockImpactsEverythingEnum.&lt;/li&gt;
&lt;li&gt;Phrase queries now leverage impacts.&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;Please read CHANGES.txt for a full list of new features and changes:&lt;/p&gt;
&lt;p&gt;&lt;a href="https://lucene.apache.org/core/8_2_0/changes/Changes.html"&gt;https://lucene.apache.org/core/8_2_0/changes/Changes.html&lt;/a&gt;&lt;/p&gt;</content><category term="core/news"></category></entry><entry><title>Apache Lucene™ 7.7.2 available</title><link href="/" rel="alternate"></link><published>2019-06-04T00:00:00+00:00</published><updated>2019-06-04T00:00:00+00:00</updated><author><name>Lucene Developers</name></author><id>tag:None,2019-06-04:/</id><summary type="html">&lt;p&gt;The Lucene PMC is pleased to announce the release of Apache Lucene 7.7.2.&lt;/p&gt;
&lt;p&gt;Apache Lucene is a high-performance, full-featured text search engine library written entirely in Java. It is a technology suitable for nearly any application that requires full-text search, especially cross-platform.&lt;/p&gt;
&lt;p&gt;This release contains 9 bugfixes in …&lt;/p&gt;</summary><content type="html">&lt;p&gt;The Lucene PMC is pleased to announce the release of Apache Lucene 7.7.2.&lt;/p&gt;
&lt;p&gt;Apache Lucene is a high-performance, full-featured text search engine library written entirely in Java. It is a technology suitable for nearly any application that requires full-text search, especially cross-platform.&lt;/p&gt;
&lt;p&gt;This release contains 9 bugfixes in Lucene. The release is available for immediate download at:&lt;/p&gt;
&lt;p&gt;&lt;a href="https://lucene.apache.org/core/downloads.html"&gt;https://lucene.apache.org/core/downloads.html&lt;/a&gt;&lt;/p&gt;
&lt;p&gt;Please read CHANGES.txt for a full list of changes:&lt;/p&gt;
&lt;p&gt;&lt;a href="https://lucene.apache.org/core/7_7_2/changes/Changes.html"&gt;https://lucene.apache.org/core/7_7_2/changes/Changes.html&lt;/a&gt;&lt;/p&gt;</content><category term="core/news"></category></entry><entry><title>Apache Lucene™ 8.1.1 available</title><link href="/" rel="alternate"></link><published>2019-05-28T00:00:00+00:00</published><updated>2019-05-28T00:00:00+00:00</updated><author><name>Lucene Developers</name></author><id>tag:None,2019-05-28:/</id><summary type="html">&lt;p&gt;The Lucene PMC is pleased to announce the release of Apache Lucene 8.1.1.&lt;/p&gt;
&lt;p&gt;Apache Lucene is a high-performance, full-featured text search engine library written entirely in Java. It is a technology suitable for nearly any application that requires full-text search, especially cross-platform.&lt;/p&gt;
&lt;p&gt;This release contains no change over …&lt;/p&gt;</summary><content type="html">&lt;p&gt;The Lucene PMC is pleased to announce the release of Apache Lucene 8.1.1.&lt;/p&gt;
&lt;p&gt;Apache Lucene is a high-performance, full-featured text search engine library written entirely in Java. It is a technology suitable for nearly any application that requires full-text search, especially cross-platform.&lt;/p&gt;
&lt;p&gt;This release contains no change over 8.1.0. The release is available for immediate download at:&lt;/p&gt;
&lt;p&gt;&lt;a href="https://lucene.apache.org/core/downloads.html"&gt;https://lucene.apache.org/core/downloads.html&lt;/a&gt;&lt;/p&gt;</content><category term="core/news"></category></entry><entry><title>Apache Lucene™ 8.1.0 available</title><link href="/" rel="alternate"></link><published>2019-05-16T00:00:00+00:00</published><updated>2019-05-16T00:00:00+00:00</updated><author><name>Lucene Developers</name></author><id>tag:None,2019-05-16:/</id><summary type="html">&lt;p&gt;The Lucene PMC is pleased to announce the release of Apache Lucene 8.1.0.&lt;/p&gt;
&lt;p&gt;Apache Lucene is a high-performance, full-featured text search engine library written entirely in Java. It is a technology suitable for nearly any application that requires full-text search, especially cross-platform.&lt;/p&gt;
&lt;p&gt;This release contains numerous bug fixes …&lt;/p&gt;</summary><content type="html">&lt;p&gt;The Lucene PMC is pleased to announce the release of Apache Lucene 8.1.0.&lt;/p&gt;
&lt;p&gt;Apache Lucene is a high-performance, full-featured text search engine library written entirely in Java. It is a technology suitable for nearly any application that requires full-text search, especially cross-platform.&lt;/p&gt;
&lt;p&gt;This release contains numerous bug fixes, optimizations, and improvements, some of which are highlighted below. The release is available for immediate download at:&lt;/p&gt;
&lt;p&gt;&lt;a href="https://lucene.apache.org/core/downloads.html"&gt;https://lucene.apache.org/core/downloads.html&lt;/a&gt;&lt;/p&gt;
&lt;h3 id="lucene-810-release-highlights"&gt;Lucene 8.1.0 Release Highlights:&lt;/h3&gt;
&lt;ul&gt;
&lt;li&gt;A query introspection API has been introduced.&lt;/li&gt;
&lt;li&gt;Luke, well-known GUI for inspecting Lucene indexes, now added as a Lucene module&lt;/li&gt;
&lt;li&gt;Merging dimensional points to use radix partitioning, which has also been optimized&lt;/li&gt;
&lt;li&gt;Bugfix: LatLonShapePolygonQuery returns incorrect WITHIN results with shared boundaries&lt;/li&gt;
&lt;li&gt;TieredMergePolicy#findForcedMerges now tries to create the cheapest merges&lt;/li&gt;
&lt;li&gt;Build point writers in the BKD tree only when they are needed&lt;/li&gt;
&lt;li&gt;SynonymQuery can now deboost the document frequency of each term when blending synonym scores&lt;/li&gt;
&lt;li&gt;ConstantScoreQuery can early terminate if minimum score &amp;gt; constant score (total hits are not requested)&lt;/li&gt;
&lt;li&gt;DateRangePrefixTree can now parse more precise dates&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;Please read CHANGES.txt for a full list of new features and changes:&lt;/p&gt;
&lt;p&gt;&lt;a href="https://lucene.apache.org/core/8_1_0/changes/Changes.html"&gt;https://lucene.apache.org/core/8_1_0/changes/Changes.html&lt;/a&gt;&lt;/p&gt;</content><category term="core/news"></category></entry><entry><title>Apache Lucene™ 6.6.6 available</title><link href="/" rel="alternate"></link><published>2019-04-05T00:00:00+00:00</published><updated>2019-04-05T00:00:00+00:00</updated><author><name>Lucene Developers</name></author><id>tag:None,2019-04-05:/</id><summary type="html">&lt;p&gt;The Lucene PMC is pleased to announce the release of Apache Lucene 6.6.6.&lt;/p&gt;
&lt;p&gt;Apache Lucene is a high-performance, full-featured text search engine library written entirely in Java. It is a technology suitable for nearly any application that requires full-text search, especially cross-pla&lt;/p&gt;
&lt;p&gt;This release contains no change over …&lt;/p&gt;</summary><content type="html">&lt;p&gt;The Lucene PMC is pleased to announce the release of Apache Lucene 6.6.6.&lt;/p&gt;
&lt;p&gt;Apache Lucene is a high-performance, full-featured text search engine library written entirely in Java. It is a technology suitable for nearly any application that requires full-text search, especially cross-pla&lt;/p&gt;
&lt;p&gt;This release contains no change over 6.6.4. The release is available for immediate download at:&lt;/p&gt;
&lt;p&gt;&lt;a href="https://www.apache.org/dyn/closer.lua/lucene/java/6.6.6"&gt;https://www.apache.org/dyn/closer.lua/lucene/java/6.6.6&lt;/a&gt;&lt;/p&gt;</content><category term="core/news"></category></entry><entry><title>Apache Lucene™ 8.0.0 available</title><link href="/" rel="alternate"></link><published>2019-03-14T00:00:00+00:00</published><updated>2019-03-14T00:00:00+00:00</updated><author><name>Lucene Developers</name></author><id>tag:None,2019-03-14:/</id><summary type="html">&lt;p&gt;The Lucene PMC is pleased to announce the release of Apache Lucene 8.0.0.&lt;/p&gt;
&lt;p&gt;Apache Lucene is a high-performance, full-featured text search engine library written entirely in Java. It is a technology suitable for nearly any application that requires full-text search, especially cross-platform.&lt;/p&gt;
&lt;p&gt;This release contains numerous bug fixes …&lt;/p&gt;</summary><content type="html">&lt;p&gt;The Lucene PMC is pleased to announce the release of Apache Lucene 8.0.0.&lt;/p&gt;
&lt;p&gt;Apache Lucene is a high-performance, full-featured text search engine library written entirely in Java. It is a technology suitable for nearly any application that requires full-text search, especially cross-platform.&lt;/p&gt;
&lt;p&gt;This release contains numerous bug fixes, optimizations, and improvements, some of which are highlighted below. The release is available for immediate download at:&lt;/p&gt;
&lt;p&gt;&lt;a href="https://lucene.apache.org/core/downloads.html"&gt;https://lucene.apache.org/core/downloads.html&lt;/a&gt;&lt;/p&gt;
&lt;h3 id="lucene-800-release-highlights"&gt;Lucene 8.0.0 Release Highlights:&lt;/h3&gt;
&lt;h4 id="query-execution"&gt;Query execution&lt;/h4&gt;
&lt;p&gt;Term queries, phrase queries and boolean queries introduced new optimization that enables efficient skipping over non-competitive documents when the total hit count is not needed. Depending on the exact query and data distribution, queries might run between a few percents slower and many times faster, especially term queries and pure disjunctions.&lt;/p&gt;
&lt;p&gt;In order to support this enhancement, some API changes have been made:
 * TopDocs.totalHits is no longer a long but an object that gives a lower bound of the actual hit count.
 * IndexSearcher's search and searchAfter methods now only compute total hit counts accurately up to 1,000 in order to enable this optimization by default.
 * Queries are now required to produce non-negative scores.&lt;/p&gt;
&lt;h4 id="codecs"&gt;Codecs&lt;/h4&gt;
&lt;ul&gt;
&lt;li&gt;Postings now index score impacts alongside skip data. This is how term queries optimize collection of top hits when hit counts are not needed.&lt;/li&gt;
&lt;li&gt;Doc values introduced jump tables, so that advancing runs in constant time. This is especially helpful on sparse fields.&lt;/li&gt;
&lt;li&gt;The terms index FST is now loaded off-heap for non-primary-key fields using MMapDirectory, reducing heap usage for such fields.&lt;/li&gt;
&lt;/ul&gt;
&lt;h4 id="custom-scoring"&gt;Custom scoring&lt;/h4&gt;
&lt;p&gt;The new FeatureField allows efficient integration of static features such as a pagerank into the score. Furthermore, the new LongPoint#newDistanceFeatureQuery and LatLonPoint#newDistanceFeatureQuery methods allow boosting by recency and geo-distance respectively. These new helpers are optimized for the case when total hit counts are not needed. For instance if the pagerank has a significant weight in your scores, then Lucene might be able to skip over documents that have a low pagerank value.&lt;/p&gt;
&lt;p&gt;Further details of changes are available in the change log available at:&lt;/p&gt;
&lt;p&gt;&lt;a href="https://lucene.apache.org/core/8_0_0/changes/Changes.html"&gt;https://lucene.apache.org/core/8_0_0/changes/Changes.html&lt;/a&gt;&lt;/p&gt;</content><category term="core/news"></category></entry><entry><title>Apache Lucene™ 7.7.1 available</title><link href="/" rel="alternate"></link><published>2019-03-01T00:00:00+00:00</published><updated>2019-03-01T00:00:00+00:00</updated><author><name>Lucene Developers</name></author><id>tag:None,2019-03-01:/</id><summary type="html">&lt;p&gt;The Lucene PMC is pleased to announce the release of Apache Lucene 7.7.1.&lt;/p&gt;
&lt;p&gt;Apache Lucene is a high-performance, full-featured text search engine library written entirely in Java. It is a technology suitable for nearly any application that requires full-text search, especially cross-platform.&lt;/p&gt;
&lt;p&gt;This release contains no change over …&lt;/p&gt;</summary><content type="html">&lt;p&gt;The Lucene PMC is pleased to announce the release of Apache Lucene 7.7.1.&lt;/p&gt;
&lt;p&gt;Apache Lucene is a high-performance, full-featured text search engine library written entirely in Java. It is a technology suitable for nearly any application that requires full-text search, especially cross-platform.&lt;/p&gt;
&lt;p&gt;This release contains no change over 7.7.0. The release is available for immediate download at:&lt;/p&gt;
&lt;p&gt;&lt;a href="https://lucene.apache.org/core/downloads.html"&gt;https://lucene.apache.org/core/downloads.html&lt;/a&gt;&lt;/p&gt;</content><category term="core/news"></category></entry><entry><title>Apache Lucene™ 7.7.0 available</title><link href="/" rel="alternate"></link><published>2019-02-11T00:00:00+00:00</published><updated>2019-02-11T00:00:00+00:00</updated><author><name>Lucene Developers</name></author><id>tag:None,2019-02-11:/</id><summary type="html">&lt;p&gt;The Lucene PMC is pleased to announce the release of Apache Lucene 7.7.0.&lt;/p&gt;
&lt;p&gt;Apache Lucene is a high-performance, full-featured text search engine library written entirely in Java. It is a technology suitable for nearly any application that requires full-text search, especially cross-platform.&lt;/p&gt;
&lt;p&gt;This release contains numerous bug fixes …&lt;/p&gt;</summary><content type="html">&lt;p&gt;The Lucene PMC is pleased to announce the release of Apache Lucene 7.7.0.&lt;/p&gt;
&lt;p&gt;Apache Lucene is a high-performance, full-featured text search engine library written entirely in Java. It is a technology suitable for nearly any application that requires full-text search, especially cross-platform.&lt;/p&gt;
&lt;p&gt;This release contains numerous bug fixes, optimizations, and improvements, some of which are highlighted below. The release is available for immediate download at:&lt;/p&gt;
&lt;p&gt;&lt;a href="https://lucene.apache.org/core/downloads.html"&gt;https://lucene.apache.org/core/downloads.html&lt;/a&gt;&lt;/p&gt;
&lt;h3 id="lucene-770-release-highlights"&gt;Lucene 7.7.0 Release Highlights:&lt;/h3&gt;
&lt;ul&gt;
&lt;li&gt;Fix LatLonShape WITHIN queries that fail with Multiple search Polygons that share the dateline.&lt;/li&gt;
&lt;li&gt;LatLonShape's within and disjoint queries can return false positives with indexed multi-shapes.&lt;/li&gt;
&lt;li&gt;ExitableDirectoryReader may now time out queries that run on points such as range queries or geo queries.&lt;/li&gt;
&lt;li&gt;StandardTokenizer and UAX29URLEmailTokenizer now support Unicode 9.0, and provide Unicode UTS#51 v11.0 Emoji tokenization with the "&lt;EMOJI&gt;" token type.&lt;/li&gt;
&lt;li&gt;TopFieldCollector can now early-terminates queries when sorting by SortField.DOC.&lt;/li&gt;
&lt;li&gt;Speed up merging segments of points with data dimensions by only sorting on the indexed dimensions.&lt;/li&gt;
&lt;li&gt;The KoreanTokenizer no longer splits unknown words on combining diacritics and detects script boundaries more accurately with Character#UnicodeScript#of.&lt;/li&gt;
&lt;li&gt;Change LatLonShape encoding to use 4 bytes Per Dimension.&lt;/li&gt;
&lt;li&gt;BufferedUpdates now uses an optimized storage for buffering docvalues updates that can save up to 80% of the heap used compared to the previous implementation and uses non-object based datastructures.&lt;/li&gt;
&lt;li&gt;Moved to the default accepted overhead ratio for packet ints in DocValuesFieldUpdates yields an up-to 4x performance improvement when applying doc values updates.&lt;/li&gt;
&lt;li&gt;Doc-value updates get applied faster by sorting with quicksort, rather than an in-place mergesort, which needs to perform fewer swaps.&lt;/li&gt;
&lt;li&gt;Decrease I/O pressure when merging high dimensional points.&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;Please read CHANGES.txt for a full list of new features and changes:&lt;/p&gt;
&lt;p&gt;&lt;a href="https://lucene.apache.org/core/7_7_0/changes/Changes.html"&gt;https://lucene.apache.org/core/7_7_0/changes/Changes.html&lt;/a&gt;&lt;/p&gt;</content><category term="core/news"></category></entry><entry><title>Apache Lucene™ 7.6.0 available</title><link href="/" rel="alternate"></link><published>2018-12-14T00:00:00+00:00</published><updated>2018-12-14T00:00:00+00:00</updated><author><name>Lucene Developers</name></author><id>tag:None,2018-12-14:/</id><summary type="html">&lt;p&gt;The Lucene PMC is pleased to announce the release of Apache Lucene 7.6.0.&lt;/p&gt;
&lt;p&gt;Apache Lucene is a high-performance, full-featured text search engine library written entirely in Java. It is a technology suitable for nearly any application that requires full-text search, especially cross-platform.&lt;/p&gt;
&lt;p&gt;This release contains numerous bug fixes …&lt;/p&gt;</summary><content type="html">&lt;p&gt;The Lucene PMC is pleased to announce the release of Apache Lucene 7.6.0.&lt;/p&gt;
&lt;p&gt;Apache Lucene is a high-performance, full-featured text search engine library written entirely in Java. It is a technology suitable for nearly any application that requires full-text search, especially cross-platform.&lt;/p&gt;
&lt;p&gt;This release contains numerous bug fixes, optimizations, and improvements, some of which are highlighted below. The release is available for immediate download at:&lt;/p&gt;
&lt;p&gt;&lt;a href="https://lucene.apache.org/core/downloads.html"&gt;https://lucene.apache.org/core/downloads.html&lt;/a&gt;&lt;/p&gt;
&lt;h3 id="lucene-760-release-highlights"&gt;Lucene 7.6.0 Release Highlights:&lt;/h3&gt;
&lt;ul&gt;
&lt;li&gt;Index sorting corruption due to numeric overflow has been fixed. Indices affected by this bug can be detected by running the CheckIndex command on a 7.6+ release distribution.&lt;/li&gt;
&lt;li&gt;Better tessellation processing of Polygons including graceful exceptions for detecting invalid shapes.&lt;/li&gt;
&lt;li&gt;Points codec now supports &lt;code&gt;selective indexing&lt;/code&gt;; the ability to designate dimensions as as "data only" dimensions that do not affect construction of the index.&lt;/li&gt;
&lt;li&gt;New Simple WKT Shape Parser builds lucene geometries (polygons, lines, rectangles) from WKT format.&lt;/li&gt;
&lt;li&gt;New LatLonShapeLineQuery queries indexed shapes with arbitrary lines.&lt;/li&gt;
&lt;li&gt;analyzeGraphPhrase query builder creates one phrase query per finite strings in the graph based on slop parameter.&lt;/li&gt;
&lt;li&gt;Performance in PerFieldMergeState#FilterFieldInfos has been improved from O(N) to O(1) lookup time.&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;Please read CHANGES.txt for a full list of new features and changes:&lt;/p&gt;
&lt;p&gt;&lt;a href="https://lucene.apache.org/core/7_6_0/changes/Changes.html"&gt;https://lucene.apache.org/core/7_6_0/changes/Changes.html&lt;/a&gt;&lt;/p&gt;</content><category term="core/news"></category></entry><entry><title>Apache Lucene™ 7.5.0 available</title><link href="/" rel="alternate"></link><published>2018-09-24T00:00:00+00:00</published><updated>2018-09-24T00:00:00+00:00</updated><author><name>Lucene Developers</name></author><id>tag:None,2018-09-24:/</id><summary type="html">&lt;p&gt;The Lucene PMC is pleased to announce the release of Apache Lucene 7.5.0.&lt;/p&gt;
&lt;p&gt;Apache Lucene is a high-performance, full-featured text search engine library written entirely in Java. It is a technology suitable for nearly any application that requires full-text search, especially cross-platform.&lt;/p&gt;
&lt;p&gt;This release contains numerous bug fixes …&lt;/p&gt;</summary><content type="html">&lt;p&gt;The Lucene PMC is pleased to announce the release of Apache Lucene 7.5.0.&lt;/p&gt;
&lt;p&gt;Apache Lucene is a high-performance, full-featured text search engine library written entirely in Java. It is a technology suitable for nearly any application that requires full-text search, especially cross-platform.&lt;/p&gt;
&lt;p&gt;This release contains numerous bug fixes, optimizations, and improvements, some of which are highlighted below. The release is available for immediate download at:&lt;/p&gt;
&lt;p&gt;&lt;a href="https://lucene.apache.org/core/downloads.html"&gt;https://lucene.apache.org/core/downloads.html&lt;/a&gt;&lt;/p&gt;
&lt;h3 id="lucene-750-release-highlights"&gt;Lucene 7.5.0 Release Highlights:&lt;/h3&gt;
&lt;ul&gt;
&lt;li&gt;IndexWriter#deleteDocs(Query... query) applies deletes to wrong documents if the index is sorted.&lt;/li&gt;
&lt;li&gt;TieredMergePolicy now respects maxSegmentSizeMB by default when executing findForcedMerges and findForcedDeletesMerges.&lt;/li&gt;
&lt;li&gt;A new points based Shape Indexing and Searching that decomposes shapes into a triangular mesh and indexes individual triangles as a 6 dimension point.&lt;/li&gt;
&lt;li&gt;A new ByteBuffer based Directory implementation that aims to replace the deprecated RAMDirectory.&lt;/li&gt;
&lt;li&gt;The UnifiedHighlighter can now use the MatchesIterator API to highlight any query more accurately.&lt;/li&gt;
&lt;li&gt;TopFieldComparator can now stop comparing documents if the index is sorted, even if hits still need to be visited to compute the hit count.&lt;/li&gt;
&lt;li&gt;TieredMergePolicy can control how aggressively deletes should be reclaimed with the new deletesPctAllowed setting.&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;Please read CHANGES.txt for a full list of new features and changes:&lt;/p&gt;
&lt;p&gt;&lt;a href="https://lucene.apache.org/core/7_5_0/changes/Changes.html"&gt;https://lucene.apache.org/core/7_5_0/changes/Changes.html&lt;/a&gt;&lt;/p&gt;</content><category term="core/news"></category></entry><entry><title>Apache Lucene™ 6.6.5 available</title><link href="/" rel="alternate"></link><published>2018-07-03T00:00:00+00:00</published><updated>2018-07-03T00:00:00+00:00</updated><author><name>Lucene Developers</name></author><id>tag:None,2018-07-03:/</id><summary type="html">&lt;p&gt;The Lucene PMC is pleased to announce the release of Apache Lucene 6.6.5.&lt;/p&gt;
&lt;p&gt;Apache Lucene is a high-performance, full-featured text search engine library written entirely in Java. It is a technology suitable for nearly any application that requires full-text search, especially cross-platform.&lt;/p&gt;
&lt;p&gt;This release contains no change over …&lt;/p&gt;</summary><content type="html">&lt;p&gt;The Lucene PMC is pleased to announce the release of Apache Lucene 6.6.5.&lt;/p&gt;
&lt;p&gt;Apache Lucene is a high-performance, full-featured text search engine library written entirely in Java. It is a technology suitable for nearly any application that requires full-text search, especially cross-platform.&lt;/p&gt;
&lt;p&gt;This release contains no change over 6.6.4. The release is available for immediate download at:&lt;/p&gt;
&lt;p&gt;&lt;a href="https://www.apache.org/dyn/closer.lua/lucene/java/6.6.5"&gt;https://www.apache.org/dyn/closer.lua/lucene/java/6.6.5&lt;/a&gt;&lt;/p&gt;</content><category term="core/news"></category></entry><entry><title>Apache Lucene™ 7.4.0 available</title><link href="/" rel="alternate"></link><published>2018-06-27T00:00:00+00:00</published><updated>2018-06-27T00:00:00+00:00</updated><author><name>Lucene Developers</name></author><id>tag:None,2018-06-27:/</id><summary type="html">&lt;p&gt;The Lucene PMC is pleased to announce the release of Apache Lucene 7.4.0.&lt;/p&gt;
&lt;p&gt;Apache Lucene is a high-performance, full-featured text search engine library written entirely in Java. It is a technology suitable for nearly any application that requires full-text search, especially cross-platform.&lt;/p&gt;
&lt;p&gt;This release contains numerous bug fixes …&lt;/p&gt;</summary><content type="html">&lt;p&gt;The Lucene PMC is pleased to announce the release of Apache Lucene 7.4.0.&lt;/p&gt;
&lt;p&gt;Apache Lucene is a high-performance, full-featured text search engine library written entirely in Java. It is a technology suitable for nearly any application that requires full-text search, especially cross-platform.&lt;/p&gt;
&lt;p&gt;This release contains numerous bug fixes, optimizations, and improvements, some of which are highlighted below. The release is available for immediate download at:&lt;/p&gt;
&lt;p&gt;&lt;a href="https://lucene.apache.org/core/downloads.html"&gt;https://lucene.apache.org/core/downloads.html&lt;/a&gt;&lt;/p&gt;
&lt;p&gt;Please read CHANGES.txt for a full list of changes:&lt;/p&gt;
&lt;p&gt;&lt;a href="https://lucene.apache.org/core/7_4_0/changes/Changes.html"&gt;https://lucene.apache.org/core/7_4_0/changes/Changes.html&lt;/a&gt;&lt;/p&gt;</content><category term="core/news"></category></entry><entry><title>Apache Lucene™ 6.6.4 available</title><link href="/" rel="alternate"></link><published>2018-05-15T00:00:00+00:00</published><updated>2018-05-15T00:00:00+00:00</updated><author><name>Lucene Developers</name></author><id>tag:None,2018-05-15:/</id><summary type="html">&lt;p&gt;The Lucene PMC is pleased to announce the release of Apache Lucene 6.6.4.&lt;/p&gt;
&lt;p&gt;Apache Lucene is a high-performance, full-featured text search engine library written entirely in Java. It is a technology suitable for nearly any application that requires full-text search, especially cross-platform.&lt;/p&gt;
&lt;p&gt;This release contains no change over …&lt;/p&gt;</summary><content type="html">&lt;p&gt;The Lucene PMC is pleased to announce the release of Apache Lucene 6.6.4.&lt;/p&gt;
&lt;p&gt;Apache Lucene is a high-performance, full-featured text search engine library written entirely in Java. It is a technology suitable for nearly any application that requires full-text search, especially cross-platform.&lt;/p&gt;
&lt;p&gt;This release contains no change over 6.6.3. The release is available for immediate download at:&lt;/p&gt;
&lt;p&gt;&lt;a href="https://www.apache.org/dyn/closer.lua/lucene/java/6.6.4"&gt;https://www.apache.org/dyn/closer.lua/lucene/java/6.6.4&lt;/a&gt;&lt;/p&gt;</content><category term="core/news"></category></entry><entry><title>Apache Lucene™ 7.3.1 available</title><link href="/" rel="alternate"></link><published>2018-05-15T00:00:00+00:00</published><updated>2018-05-15T00:00:00+00:00</updated><author><name>Lucene Developers</name></author><id>tag:None,2018-05-15:/</id><summary type="html">&lt;p&gt;The Lucene PMC is pleased to announce the release of Apache Lucene 7.3.1.&lt;/p&gt;
&lt;p&gt;Apache Lucene is a high-performance, full-featured text search engine library written entirely in Java. It is a technology suitable for nearly any application that requires full-text search, especially cross-platform.&lt;/p&gt;
&lt;p&gt;This release contains one build change …&lt;/p&gt;</summary><content type="html">&lt;p&gt;The Lucene PMC is pleased to announce the release of Apache Lucene 7.3.1.&lt;/p&gt;
&lt;p&gt;Apache Lucene is a high-performance, full-featured text search engine library written entirely in Java. It is a technology suitable for nearly any application that requires full-text search, especially cross-platform.&lt;/p&gt;
&lt;p&gt;This release contains one build change. The release is available for immediate download at:&lt;/p&gt;
&lt;p&gt;&lt;a href="https://lucene.apache.org/core/mirrors-core-redir.html"&gt;https://lucene.apache.org/core/mirrors-core-redir.html&lt;/a&gt;&lt;/p&gt;
&lt;p&gt;Please read CHANGES.txt for a full list of changes:&lt;/p&gt;
&lt;p&gt;&lt;a href="https://lucene.apache.org/core/7_3_1/changes/Changes.html"&gt;https://lucene.apache.org/core/7_3_1/changes/Changes.html&lt;/a&gt;&lt;/p&gt;</content><category term="core/news"></category></entry><entry><title>Apache Lucene™ 7.3.0 available</title><link href="/" rel="alternate"></link><published>2018-04-04T00:00:00+00:00</published><updated>2018-04-04T00:00:00+00:00</updated><author><name>Lucene Developers</name></author><id>tag:None,2018-04-04:/</id><summary type="html">&lt;p&gt;The Lucene PMC is pleased to announce the release of Apache Lucene 7.3.0.&lt;/p&gt;
&lt;p&gt;Apache Lucene is a high-performance, full-featured text search engine library written entirely in Java. It is a technology suitable for nearly any application that requires full-text search, especially cross-platform.&lt;/p&gt;
&lt;p&gt;This release contains numerous bug fixes …&lt;/p&gt;</summary><content type="html">&lt;p&gt;The Lucene PMC is pleased to announce the release of Apache Lucene 7.3.0.&lt;/p&gt;
&lt;p&gt;Apache Lucene is a high-performance, full-featured text search engine library written entirely in Java. It is a technology suitable for nearly any application that requires full-text search, especially cross-platform.&lt;/p&gt;
&lt;p&gt;This release contains numerous bug fixes, optimizations, and improvements, some of which are highlighted below. The release is available for immediate download at:&lt;/p&gt;
&lt;p&gt;&lt;a href="https://lucene.apache.org/core/mirrors-core-redir.html"&gt;https://lucene.apache.org/core/mirrors-core-redir.html&lt;/a&gt;&lt;/p&gt;
&lt;p&gt;Please read CHANGES.txt for a full list of changes:&lt;/p&gt;
&lt;p&gt;&lt;a href="https://lucene.apache.org/core/7_3_0/changes/Changes.html"&gt;https://lucene.apache.org/core/7_3_0/changes/Changes.html&lt;/a&gt;&lt;/p&gt;</content><category term="core/news"></category></entry><entry><title>Apache Lucene™ 6.6.3 available</title><link href="/" rel="alternate"></link><published>2018-03-07T00:00:00+00:00</published><updated>2018-03-07T00:00:00+00:00</updated><author><name>Lucene Developers</name></author><id>tag:None,2018-03-07:/</id><summary type="html">&lt;p&gt;The Lucene PMC is pleased to announce the release of Apache Lucene 6.6.3.&lt;/p&gt;
&lt;p&gt;Apache Lucene is a high-performance, full-featured text search engine library written entirely in Java. It is a technology suitable for nearly any application that requires full-text search, especially cross-platform.&lt;/p&gt;
&lt;p&gt;This release contains one build change …&lt;/p&gt;</summary><content type="html">&lt;p&gt;The Lucene PMC is pleased to announce the release of Apache Lucene 6.6.3.&lt;/p&gt;
&lt;p&gt;Apache Lucene is a high-performance, full-featured text search engine library written entirely in Java. It is a technology suitable for nearly any application that requires full-text search, especially cross-platform.&lt;/p&gt;
&lt;p&gt;This release contains one build change. The release is available for immediate download at:&lt;/p&gt;
&lt;p&gt;&lt;a href="https://lucene.apache.org/core/mirrors-core-redir.html"&gt;https://lucene.apache.org/core/mirrors-core-redir.html&lt;/a&gt;&lt;/p&gt;
&lt;p&gt;Please read CHANGES.txt for a full list of changes:&lt;/p&gt;
&lt;p&gt;&lt;a href="https://lucene.apache.org/core/6_6_3/changes/Changes.html"&gt;https://lucene.apache.org/core/6_6_3/changes/Changes.html&lt;/a&gt;&lt;/p&gt;</content><category term="core/news"></category></entry><entry><title>Apache Lucene™ 7.2.1 available</title><link href="/" rel="alternate"></link><published>2018-01-15T00:00:00+00:00</published><updated>2018-01-15T00:00:00+00:00</updated><author><name>Lucene Developers</name></author><id>tag:None,2018-01-15:/</id><summary type="html">&lt;p&gt;The Lucene PMC is pleased to announce the release of Apache Lucene 7.2.1.&lt;/p&gt;
&lt;p&gt;Apache Lucene is a high-performance, full-featured text search engine library written entirely in Java. It is a technology suitable for nearly any application that requires full-text search, especially cross-platform.&lt;/p&gt;
&lt;p&gt;This release contains one bug fix …&lt;/p&gt;</summary><content type="html">&lt;p&gt;The Lucene PMC is pleased to announce the release of Apache Lucene 7.2.1.&lt;/p&gt;
&lt;p&gt;Apache Lucene is a high-performance, full-featured text search engine library written entirely in Java. It is a technology suitable for nearly any application that requires full-text search, especially cross-platform.&lt;/p&gt;
&lt;p&gt;This release contains one bug fix. The release is available for immediate download at:&lt;/p&gt;
&lt;p&gt;&lt;a href="https://lucene.apache.org/core/mirrors-core-latest-redir.html"&gt;https://lucene.apache.org/core/mirrors-core-latest-redir.html&lt;/a&gt;&lt;/p&gt;
&lt;p&gt;Please read CHANGES.txt for a full list of new features and changes:&lt;/p&gt;
&lt;p&gt;&lt;a href="https://lucene.apache.org/core/7_2_1/changes/Changes.html"&gt;https://lucene.apache.org/core/7_2_1/changes/Changes.html&lt;/a&gt;&lt;/p&gt;
&lt;h3 id="lucene-721-bug-fix"&gt;Lucene 7.2.1 Bug Fix:&lt;/h3&gt;
&lt;ul&gt;
&lt;li&gt;Fix advanceExact on SortedNumericDocValues produced by Lucene54DocValuesProducer.&lt;/li&gt;
&lt;/ul&gt;</content><category term="core/news"></category></entry><entry><title>Apache Lucene™ 7.2.0 available</title><link href="/" rel="alternate"></link><published>2017-12-21T00:00:00+00:00</published><updated>2017-12-21T00:00:00+00:00</updated><author><name>Lucene Developers</name></author><id>tag:None,2017-12-21:/</id><summary type="html">&lt;p&gt;The Lucene PMC is pleased to announce the release of Apache Lucene 7.2.0.&lt;/p&gt;
&lt;p&gt;Apache Lucene is a high-performance, full-featured text search engine library written entirely in Java. It is a technology suitable for nearly any application that requires full-text search, especially cross-platform.&lt;/p&gt;
&lt;p&gt;This release contains numerous bug fixes …&lt;/p&gt;</summary><content type="html">&lt;p&gt;The Lucene PMC is pleased to announce the release of Apache Lucene 7.2.0.&lt;/p&gt;
&lt;p&gt;Apache Lucene is a high-performance, full-featured text search engine library written entirely in Java. It is a technology suitable for nearly any application that requires full-text search, especially cross-platform.&lt;/p&gt;
&lt;p&gt;This release contains numerous bug fixes, optimizations, and improvements, some of which are highlighted below. The release is available for immediate download at:&lt;/p&gt;
&lt;p&gt;&lt;a href="https://lucene.apache.org/core/mirrors-core-latest-redir.html"&gt;https://lucene.apache.org/core/mirrors-core-latest-redir.html&lt;/a&gt;&lt;/p&gt;
&lt;p&gt;Please read CHANGES.txt for a full list of new features and changes:&lt;/p&gt;
&lt;p&gt;&lt;a href="https://lucene.apache.org/core/7_2_0/changes/Changes.html"&gt;https://lucene.apache.org/core/7_2_0/changes/Changes.html&lt;/a&gt;&lt;/p&gt;
&lt;h3 id="lucene-720-release-highlights"&gt;Lucene 7.2.0 Release Highlights:&lt;/h3&gt;
&lt;ul&gt;
&lt;li&gt;Specific query implementations can now opt out of caching.&lt;/li&gt;
&lt;li&gt;TopFieldDocCollector can now early terminate collection of matches when the index is sorted and the total hit count is not requested.&lt;/li&gt;
&lt;li&gt;IndexWriter#flushNextBuffer gives more fine-grained control over the memory usage of IndexWriter.&lt;/li&gt;
&lt;li&gt;Fixed document accounting in IndexWriter.&lt;/li&gt;
&lt;li&gt;Query scores can be exposed in a ValuesSource using DoubleValuesSource.fromQuery().&lt;/li&gt;
&lt;/ul&gt;</content><category term="core/news"></category></entry><entry><title>Apache Lucene™ 5.5.5 available</title><link href="/" rel="alternate"></link><published>2017-10-24T00:00:00+00:00</published><updated>2017-10-24T00:00:00+00:00</updated><author><name>Lucene Developers</name></author><id>tag:None,2017-10-24:/</id><summary type="html">&lt;p&gt;The Lucene PMC is pleased to announce the release of Apache Lucene 5.5.5.&lt;/p&gt;
&lt;p&gt;Apache Lucene is a high-performance, full-featured text search engine library written entirely in Java. It is a technology suitable for nearly any application that requires full-text search, especially cross-platform.&lt;/p&gt;
&lt;p&gt;This release contains one bug fix …&lt;/p&gt;</summary><content type="html">&lt;p&gt;The Lucene PMC is pleased to announce the release of Apache Lucene 5.5.5.&lt;/p&gt;
&lt;p&gt;Apache Lucene is a high-performance, full-featured text search engine library written entirely in Java. It is a technology suitable for nearly any application that requires full-text search, especially cross-platform.&lt;/p&gt;
&lt;p&gt;This release contains one bug fix. The release is available for immediate download at:&lt;/p&gt;
&lt;p&gt;&lt;a href="https://lucene.apache.org/core/mirrors-core-latest-redir.html"&gt;https://lucene.apache.org/core/mirrors-core-latest-redir.html&lt;/a&gt;&lt;/p&gt;
&lt;p&gt;Please read CHANGES.txt for a full list of new features and changes:&lt;/p&gt;
&lt;p&gt;&lt;a href="https://lucene.apache.org/core/5_5_5/changes/Changes.html"&gt;https://lucene.apache.org/core/5_5_5/changes/Changes.html&lt;/a&gt;&lt;/p&gt;
&lt;p&gt;This release includes a critical security fix. Details:&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;Disallow resolving of external entities in queryparser/xml/CoreParser by default.&lt;/li&gt;
&lt;/ul&gt;</content><category term="core/news"></category></entry><entry><title>Apache Lucene™ 6.6.2 available</title><link href="/" rel="alternate"></link><published>2017-10-18T00:00:00+00:00</published><updated>2017-10-18T00:00:00+00:00</updated><author><name>Lucene Developers</name></author><id>tag:None,2017-10-18:/</id><summary type="html">&lt;p&gt;The Lucene PMC is pleased to announce the release of Apache Lucene 6.6.2.&lt;/p&gt;
&lt;p&gt;Apache Lucene is a high-performance, full-featured text search engine library written entirely in Java. It is a technology suitable for nearly any application that requires full-text search, especially cross-platform.&lt;/p&gt;
&lt;p&gt;This release contains numerous bug fixes …&lt;/p&gt;</summary><content type="html">&lt;p&gt;The Lucene PMC is pleased to announce the release of Apache Lucene 6.6.2.&lt;/p&gt;
&lt;p&gt;Apache Lucene is a high-performance, full-featured text search engine library written entirely in Java. It is a technology suitable for nearly any application that requires full-text search, especially cross-platform.&lt;/p&gt;
&lt;p&gt;This release contains numerous bug fixes, optimizations, and improvements, some of which are highlighted below. The release is available for immediate download at:&lt;/p&gt;
&lt;p&gt;&lt;a href="https://www.apache.org/dyn/closer.lua/lucene/java/6.6.2"&gt;https://www.apache.org/dyn/closer.lua/lucene/java/6.6.2&lt;/a&gt;&lt;/p&gt;
&lt;p&gt;Please read CHANGES.txt for a full list of new features and changes:&lt;/p&gt;
&lt;p&gt;&lt;a href="https://lucene.apache.org/core/6_6_2/changes/Changes.html"&gt;https://lucene.apache.org/core/6_6_2/changes/Changes.html&lt;/a&gt;&lt;/p&gt;
&lt;p&gt;This release includes a critical security fix. Details:&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;Disallow resolving of external entities in queryparser/xml/CoreParser by default.&lt;/li&gt;
&lt;/ul&gt;</content><category term="core/news"></category></entry><entry><title>Apache Lucene™ 7.1.0 available</title><link href="/" rel="alternate"></link><published>2017-10-17T00:00:00+00:00</published><updated>2017-10-17T00:00:00+00:00</updated><author><name>Lucene Developers</name></author><id>tag:None,2017-10-17:/</id><summary type="html">&lt;p&gt;The Lucene PMC is pleased to announce the release of Apache Lucene 7.1.0.&lt;/p&gt;
&lt;p&gt;Apache Lucene is a high-performance, full-featured text search engine library written entirely in Java. It is a technology suitable for nearly any application that requires full-text search, especially cross-platform.&lt;/p&gt;
&lt;p&gt;This release contains numerous bug fixes …&lt;/p&gt;</summary><content type="html">&lt;p&gt;The Lucene PMC is pleased to announce the release of Apache Lucene 7.1.0.&lt;/p&gt;
&lt;p&gt;Apache Lucene is a high-performance, full-featured text search engine library written entirely in Java. It is a technology suitable for nearly any application that requires full-text search, especially cross-platform.&lt;/p&gt;
&lt;p&gt;This release contains numerous bug fixes, optimizations, and improvements, some of which are highlighted below.&lt;/p&gt;
&lt;p&gt;The release is available for immediate download at:&lt;/p&gt;
&lt;p&gt;&lt;a href="https://www.apache.org/dyn/closer.lua/lucene/java/7.1.0"&gt;https://www.apache.org/dyn/closer.lua/lucene/java/7.1.0&lt;/a&gt;&lt;/p&gt;
&lt;p&gt;Please read CHANGES.txt for a full list of new features and changes:&lt;/p&gt;
&lt;p&gt;&lt;a href="https://lucene.apache.org/core/7_1_0/changes/Changes.html"&gt;https://lucene.apache.org/core/7_1_0/changes/Changes.html&lt;/a&gt;&lt;/p&gt;
&lt;h3 id="lucene-710-release-highlights"&gt;Lucene 7.1.0 Release Highlights:&lt;/h3&gt;
&lt;ul&gt;
&lt;li&gt;
&lt;p&gt;New Geo3D shapes for non-spherical planet models&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;Serialization and deserialization support for Geo3D&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;A new CoveringQuery, whose required number of matching clauses can be defined per document&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;New BengaliAnalyzer for Bengali language&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;A point based range field called LatLonBoundingBox&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;FloatPointNearestNeighbor, an N-dimensional FloatPoint K-nearest-neighbor search implementation&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;Faster default taxonomy cache&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;Support for computing facet counts for individual numeric values via LongValueFacetCounts&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;Faster geo-distance queries in case of dense single-valued fields when most documents match&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;Better heuristics in IndexOrDocValuesQuery&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;Optimized builds for OrdinalMap (used by SortedSetDocValuesFacetCounts and others)&lt;/p&gt;
&lt;/li&gt;
&lt;/ul&gt;</content><category term="core/news"></category></entry><entry><title>Apache Lucene™ 7.0.1 available</title><link href="/" rel="alternate"></link><published>2017-10-06T00:00:00+00:00</published><updated>2017-10-06T00:00:00+00:00</updated><author><name>Lucene Developers</name></author><id>tag:None,2017-10-06:/</id><summary type="html">&lt;p&gt;The Lucene PMC is pleased to announce the release of Apache Lucene 7.0.1&lt;/p&gt;
&lt;p&gt;Apache Lucene is a high-performance, full-featured text search engine library written entirely in Java. It is a technology suitable for nearly any application that requires full-text search, especially cross-platform.&lt;/p&gt;
&lt;p&gt;This release contains 1 bug fix …&lt;/p&gt;</summary><content type="html">&lt;p&gt;The Lucene PMC is pleased to announce the release of Apache Lucene 7.0.1&lt;/p&gt;
&lt;p&gt;Apache Lucene is a high-performance, full-featured text search engine library written entirely in Java. It is a technology suitable for nearly any application that requires full-text search, especially cross-platform.&lt;/p&gt;
&lt;p&gt;This release contains 1 bug fix since the 7.0.0 release:&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;ConjunctionScorer.getChildren was failing to return all child scorers&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;The release is available for immediate download at:&lt;/p&gt;
&lt;p&gt;&lt;a href="https://www.apache.org/dyn/closer.lua/lucene/java/7.0.1"&gt;https://www.apache.org/dyn/closer.lua/lucene/java/7.0.1&lt;/a&gt;&lt;/p&gt;
&lt;p&gt;Please read CHANGES.txt for a full list of new features and changes:&lt;/p&gt;
&lt;p&gt;&lt;a href="https://lucene.apache.org/core/7_0_1/changes/Changes.html"&gt;https://lucene.apache.org/core/7_0_1/changes/Changes.html&lt;/a&gt;&lt;/p&gt;</content><category term="core/news"></category></entry><entry><title>Apache Lucene™ 7.0.0 available</title><link href="/" rel="alternate"></link><published>2017-09-20T00:00:00+00:00</published><updated>2017-09-20T00:00:00+00:00</updated><author><name>Lucene Developers</name></author><id>tag:None,2017-09-20:/</id><summary type="html">&lt;p&gt;The Lucene PMC is pleased to announce the release of Apache Lucene 7.0.0.&lt;/p&gt;
&lt;p&gt;Apache Lucene is a high-performance, full-featured text search engine library written entirely in Java. It is a technology suitable for nearly any application that requires full-text search, especially cross-platform.&lt;/p&gt;
&lt;p&gt;This release contains numerous bug fixes …&lt;/p&gt;</summary><content type="html">&lt;p&gt;The Lucene PMC is pleased to announce the release of Apache Lucene 7.0.0.&lt;/p&gt;
&lt;p&gt;Apache Lucene is a high-performance, full-featured text search engine library written entirely in Java. It is a technology suitable for nearly any application that requires full-text search, especially cross-platform.&lt;/p&gt;
&lt;p&gt;This release contains numerous bug fixes, optimizations, and improvements, some of which are highlighted below. The release is available for immediate download at:&lt;/p&gt;
&lt;p&gt;&lt;a href="https://www.apache.org/dyn/closer.lua/lucene/java/7.0.0"&gt;https://www.apache.org/dyn/closer.lua/lucene/java/7.0.0&lt;/a&gt;&lt;/p&gt;
&lt;p&gt;Please read CHANGES.txt for a full list of new features and changes:&lt;/p&gt;
&lt;p&gt;&lt;a href="https://lucene.apache.org/core/7_0_0/changes/Changes.html"&gt;https://lucene.apache.org/core/7_0_0/changes/Changes.html&lt;/a&gt;&lt;/p&gt;
&lt;h3 id="lucene-700-release-highlights"&gt;Lucene 7.0.0 Release Highlights:&lt;/h3&gt;
&lt;ul&gt;
&lt;li&gt;
&lt;p&gt;Doc values switched from random access to iterators.&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;The 7.0 codec now sparsely encodes sparse doc values and length normalization factors ("norms"), which also translates to optimization in both indexing, and search on sparse values. With these changes, you finally only pay for what you actually use with doc values, in index size, indexing performance, etc.&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;Index time boost for documents is now removed.&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;Substantial performance gains for delete and update heavy Lucene usage; see http://blog.mikemccandless.com/2017/07/lucene-gets-concurrent-deletes-and.html for details&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;Query scoring is now simpler with removal of coord factor, and query normalization.&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;Classic query parser no longer splits on whitespaces.  This enables better multi-word synonym support.&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;The version of Lucene that created the index segment would be recorded, along with the version that last modified the index.&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;IndexWriter, used to add, update and delete documents in your index, will no longer accept broken token offsets sometimes produced by mis-behaving token filters.&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;IndexReader exposes methods that are typically used to manage resources whose lifetime needs to mimic the lifetime of segments/indexes, typically caches. They have been made much less trappy.&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;The dimensional points API now takes a field name up front to offer per-field points access, matching how the doc values APIs work.&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;The PostingsHighlighter was removed.  Migrating to the UnifiedHighlighter should be straight-forward.&lt;/p&gt;
&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;Apache Lucene was tested to be fully compatible with the release of Java 9 and its module system Jigsaw, coming out tomorrow on September 21st!&lt;/p&gt;</content><category term="core/news"></category></entry><entry><title>Apache Lucene™ 6.6.1 available</title><link href="/" rel="alternate"></link><published>2017-09-07T00:00:00+00:00</published><updated>2017-09-07T00:00:00+00:00</updated><author><name>Lucene Developers</name></author><id>tag:None,2017-09-07:/</id><summary type="html">&lt;p&gt;The Lucene PMC is pleased to announce the release of Apache Lucene 6.6.1&lt;/p&gt;
&lt;p&gt;Apache Lucene is a high-performance, full-featured text search engine
library written entirely in Java. It is a technology suitable for nearly
any application that requires full-text search, especially cross-platform.&lt;/p&gt;
&lt;p&gt;The release is available for immediate …&lt;/p&gt;</summary><content type="html">&lt;p&gt;The Lucene PMC is pleased to announce the release of Apache Lucene 6.6.1&lt;/p&gt;
&lt;p&gt;Apache Lucene is a high-performance, full-featured text search engine
library written entirely in Java. It is a technology suitable for nearly
any application that requires full-text search, especially cross-platform.&lt;/p&gt;
&lt;p&gt;The release is available for immediate download at:&lt;/p&gt;
&lt;p&gt;&lt;a href="https://www.apache.org/dyn/closer.lua/lucene/java/6.6.1"&gt;https://www.apache.org/dyn/closer.lua/lucene/java/6.6.1&lt;/a&gt;&lt;/p&gt;
&lt;p&gt;See the &lt;a href="/core/6_6_1/changes/Changes.html"&gt;CHANGES.txt&lt;/a&gt; file included with the
release for a full list of changes and further details.&lt;/p&gt;
&lt;p&gt;This release contains 2 bug fixes since the 6.6.0 release:&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;
&lt;p&gt;Documents with multiple points that should match might not match on a memory index&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;A query which has only one synonym with AND as the default operator would
   wrongly translate as an AND between the query term and the synonym&lt;/p&gt;
&lt;/li&gt;
&lt;/ul&gt;</content><category term="core/news"></category></entry><entry><title>Apache Lucene™ 6.6.0 available</title><link href="/" rel="alternate"></link><published>2017-06-06T00:00:00+00:00</published><updated>2017-06-06T00:00:00+00:00</updated><author><name>Lucene Developers</name></author><id>tag:None,2017-06-06:/</id><summary type="html">&lt;p&gt;The Lucene PMC is pleased to announce the release of Apache Lucene 6.6.0&lt;/p&gt;
&lt;p&gt;Apache Lucene is a high-performance, full-featured text search engine
library written entirely in Java. It is a technology suitable for nearly
any application that requires full-text search, especially cross-platform.&lt;/p&gt;
&lt;p&gt;The release is available for immediate …&lt;/p&gt;</summary><content type="html">&lt;p&gt;The Lucene PMC is pleased to announce the release of Apache Lucene 6.6.0&lt;/p&gt;
&lt;p&gt;Apache Lucene is a high-performance, full-featured text search engine
library written entirely in Java. It is a technology suitable for nearly
any application that requires full-text search, especially cross-platform.&lt;/p&gt;
&lt;p&gt;The release is available for immediate download at:&lt;/p&gt;
&lt;p&gt;&lt;a href="https://www.apache.org/dyn/closer.lua/lucene/java/6.6.0"&gt;https://www.apache.org/dyn/closer.lua/lucene/java/6.6.0&lt;/a&gt;&lt;/p&gt;
&lt;p&gt;See the &lt;a href="/core/6_6_0/changes/Changes.html"&gt;CHANGES.txt&lt;/a&gt; file included with the
release for a full list of changes and further details.&lt;/p&gt;
&lt;h3 id="highlights-of-this-lucene-release-include"&gt;Highlights of this Lucene release include:&lt;/h3&gt;
&lt;ul&gt;
&lt;li&gt;
&lt;p&gt;A concurrent SortedSet facets implementation&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;spatial-extras HeatmapFacetCounter will now short-circuit it's work when Bits.MatchNoBits is passed&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;OfflineSorter now passes the total number of items it will write to getWriter()&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;Move dictionary for Ukrainian analyzer to external dependency&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;SortedSetDocValuesReaderState now implements Accountable so one can see how much RAM it is using&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;OfflineSorter can now run concurrently if you pass it an optional ExecutorService Sorted set facets now
use sparse storage when collecting hits, when appropriate&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;PostingsHighlighter has been deprecated in favour of the UnifiedHighlighter&lt;/p&gt;
&lt;/li&gt;
&lt;/ul&gt;</content><category term="core/news"></category></entry><entry><title>Apache Lucene™ 6.5.1 available</title><link href="/" rel="alternate"></link><published>2017-04-27T00:00:00+00:00</published><updated>2017-04-27T00:00:00+00:00</updated><author><name>Lucene Developers</name></author><id>tag:None,2017-04-27:/</id><summary type="html">&lt;p&gt;The Lucene PMC is pleased to announce the release of Apache Lucene 6.5.1&lt;/p&gt;
&lt;p&gt;Apache Lucene is a high-performance, full-featured text search engine
library written entirely in Java. It is a technology suitable for nearly
any application that requires full-text search, especially cross-platform.&lt;/p&gt;
&lt;p&gt;The release is available for immediate …&lt;/p&gt;</summary><content type="html">&lt;p&gt;The Lucene PMC is pleased to announce the release of Apache Lucene 6.5.1&lt;/p&gt;
&lt;p&gt;Apache Lucene is a high-performance, full-featured text search engine
library written entirely in Java. It is a technology suitable for nearly
any application that requires full-text search, especially cross-platform.&lt;/p&gt;
&lt;p&gt;The release is available for immediate download at:&lt;/p&gt;
&lt;p&gt;&lt;a href="https://www.apache.org/dyn/closer.lua/lucene/java/6.5.1"&gt;https://www.apache.org/dyn/closer.lua/lucene/java/6.5.1&lt;/a&gt;&lt;/p&gt;
&lt;p&gt;See the &lt;a href="/core/6_5_1/changes/Changes.html"&gt;CHANGES.txt&lt;/a&gt; file included with the
release for a full list of changes and further details.&lt;/p&gt;
&lt;p&gt;This release contains 3 bug fixes since the 6.5.0 release:&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;
&lt;p&gt;Fixed join queries to not reference IndexReaders, as it could cause leaks if they are cached.&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;Made LRUQueryCache delegate the scoreSupplier method.&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;Fixed index sorting to work with sparse numeric and binary docvalues field&lt;/p&gt;
&lt;/li&gt;
&lt;/ul&gt;</content><category term="core/news"></category></entry><entry><title>Apache Lucene™ 6.5.0 available</title><link href="/" rel="alternate"></link><published>2017-03-27T00:00:00+00:00</published><updated>2017-03-27T00:00:00+00:00</updated><author><name>Lucene Developers</name></author><id>tag:None,2017-03-27:/</id><summary type="html">&lt;p&gt;The Lucene PMC is pleased to announce the release of Apache Lucene 6.5.0&lt;/p&gt;
&lt;p&gt;Apache Lucene is a high-performance, full-featured text search engine
library written entirely in Java. It is a technology suitable for nearly
any application that requires full-text search, especially cross-platform.&lt;/p&gt;
&lt;p&gt;This release contains numerous bug fixes …&lt;/p&gt;</summary><content type="html">&lt;p&gt;The Lucene PMC is pleased to announce the release of Apache Lucene 6.5.0&lt;/p&gt;
&lt;p&gt;Apache Lucene is a high-performance, full-featured text search engine
library written entirely in Java. It is a technology suitable for nearly
any application that requires full-text search, especially cross-platform.&lt;/p&gt;
&lt;p&gt;This release contains numerous bug fixes, optimizations, and
improvements, some of which are highlighted below.
The release is available for immediate download at:&lt;/p&gt;
&lt;p&gt;&lt;a href="https://www.apache.org/dyn/closer.lua/lucene/java/6.5.0"&gt;https://www.apache.org/dyn/closer.lua/lucene/java/6.5.0&lt;/a&gt;&lt;/p&gt;
&lt;p&gt;See the &lt;a href="/core/6_5_0/changes/Changes.html"&gt;CHANGES.txt&lt;/a&gt; file included with the
release for a full list of changes and further details.&lt;/p&gt;
&lt;h3 id="highlights-of-this-lucene-release-include"&gt;Highlights of this Lucene release include:&lt;/h3&gt;
&lt;ul&gt;
&lt;li&gt;
&lt;p&gt;It is now possible filter out duplicates in the NRT suggester&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;SimpleQueryString now supports default fuziness&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;IndexWriter can return the list of visible field names&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;DisjunctionScorer now supports returning the matching children clauses&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;A new FunctionScoreQuery that modifies the internal query's score using the per-document values&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;A new FunctionMatchQuery that returns any documents with a value that matches a predicate&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;A new WordDelimiterGraphFilter that outputs a correct graph structure for multi-token expansion at query time&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;A new PatternTokenizer that uses Lucene's RegExp implementation&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;RangeFieldQuery now supports CROSSES relation&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;A new IndexOrDocValuesQuery that uses either an index (points or terms) or doc values in order to run a (range, geo box and distance) query, depending which one is more efficient&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;index-time boosts are deprecated&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;Term filters are no longer cached&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;Compound filters are cached earlier than regular queries&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;BKDReader now calls grow on larger increments&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;LatLonPointInPolygonQuery are faster&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;LatLonPointDistanceQuery now skips distance computations more often&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;To-parent block joins now implements two-phase iteration&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;Point ranges that match most documents are faster&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;PointValues#estimatePointCount is faster with Relation.CELL_INSIDE_QUERY&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;Segments are now also sorted during flush, and merging on a sorted index is substantially faster by using some of the same bulk merge optimizations that non-sorted merging uses&lt;/p&gt;
&lt;/li&gt;
&lt;/ul&gt;</content><category term="core/news"></category></entry><entry><title>Apache Lucene 6.4.2 and Apache Solr 6.4.2 Available</title><link href="/" rel="alternate"></link><published>2017-03-07T00:00:00+00:00</published><updated>2017-03-07T00:00:00+00:00</updated><author><name>Lucene Developers</name></author><id>tag:None,2017-03-07:/</id><summary type="html">&lt;p&gt;The Lucene PMC is pleased to announce the release of Apache Lucene 6.4.2&lt;/p&gt;
&lt;p&gt;Apache Lucene is a high-performance, full-featured text search engine
library written entirely in Java. It is a technology suitable for nearly
any application that requires full-text search, especially cross-platform.&lt;/p&gt;
&lt;p&gt;This release contains numerous bug fixes …&lt;/p&gt;</summary><content type="html">&lt;p&gt;The Lucene PMC is pleased to announce the release of Apache Lucene 6.4.2&lt;/p&gt;
&lt;p&gt;Apache Lucene is a high-performance, full-featured text search engine
library written entirely in Java. It is a technology suitable for nearly
any application that requires full-text search, especially cross-platform.&lt;/p&gt;
&lt;p&gt;This release contains numerous bug fixes, optimizations, and
improvements, some of which are highlighted below.
The release is available for immediate download at:&lt;/p&gt;
&lt;p&gt;&lt;a href="https://www.apache.org/dyn/closer.lua/lucene/java/6.4.2"&gt;https://www.apache.org/dyn/closer.lua/lucene/java/6.4.2&lt;/a&gt;&lt;/p&gt;
&lt;p&gt;See the &lt;a href="/core/6_4_2/changes/Changes.html"&gt;CHANGES.txt&lt;/a&gt; file included with the
release for a full list of changes and further details.&lt;/p&gt;
&lt;h3 id="highlights-of-this-lucene-release-include"&gt;Highlights of this Lucene release include:&lt;/h3&gt;
&lt;ul&gt;
&lt;li&gt;Fixed: CommonGramsQueryFilter was producing a disconnected token graph, messing up phrase queries during query parsing&lt;/li&gt;
&lt;/ul&gt;</content><category term="core/news"></category></entry><entry><title>Apache Lucene™ 5.5.4 available</title><link href="/" rel="alternate"></link><published>2017-02-15T00:00:00+00:00</published><updated>2017-02-15T00:00:00+00:00</updated><author><name>Lucene Developers</name></author><id>tag:None,2017-02-15:/</id><summary type="html">&lt;p&gt;The Lucene PMC is pleased to announce the release of Apache Lucene 5.5.4&lt;/p&gt;
&lt;p&gt;Apache Lucene is a high-performance, full-featured text search engine
library written entirely in Java. It is a technology suitable for nearly
any application that requires full-text search, especially cross-platform.&lt;/p&gt;
&lt;p&gt;This release contains numerous bug fixes …&lt;/p&gt;</summary><content type="html">&lt;p&gt;The Lucene PMC is pleased to announce the release of Apache Lucene 5.5.4&lt;/p&gt;
&lt;p&gt;Apache Lucene is a high-performance, full-featured text search engine
library written entirely in Java. It is a technology suitable for nearly
any application that requires full-text search, especially cross-platform.&lt;/p&gt;
&lt;p&gt;This release contains numerous bug fixes, optimizations, and
improvements, some of which are highlighted below.
The release is available for immediate download at:&lt;/p&gt;
&lt;p&gt;&lt;a href="https://www.apache.org/dyn/closer.lua/lucene/java/5.5.4"&gt;https://www.apache.org/dyn/closer.lua/lucene/java/5.5.4&lt;/a&gt;&lt;/p&gt;
&lt;p&gt;See the &lt;a href="/core/5_5_4/changes/Changes.html"&gt;CHANGES.txt&lt;/a&gt; file included with the
release for a full list of changes and further details.&lt;/p&gt;
&lt;h3 id="highlights-of-this-lucene-release-include"&gt;Highlights of this Lucene release include:&lt;/h3&gt;
&lt;ul&gt;
&lt;li&gt;
&lt;p&gt;Made stored fields reclaim native memory more aggressively&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;Fixed a potential memory leak with LRUQueryCache and (Span)TermQuery&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;MmapDirectory's unmapping code is now compatible with Java 9 (EA build 150 and later)&lt;/p&gt;
&lt;/li&gt;
&lt;/ul&gt;</content><category term="core/news"></category></entry><entry><title>Apache Lucene™ 6.4.1 available</title><link href="/" rel="alternate"></link><published>2017-02-06T00:00:00+00:00</published><updated>2017-02-06T00:00:00+00:00</updated><author><name>Lucene Developers</name></author><id>tag:None,2017-02-06:/</id><summary type="html">&lt;p&gt;The Lucene PMC is pleased to announce the release of Apache Lucene 6.4.1&lt;/p&gt;
&lt;p&gt;Apache Lucene is a high-performance, full-featured text search engine
library written entirely in Java. It is a technology suitable for nearly
any application that requires full-text search, especially cross-platform.&lt;/p&gt;
&lt;p&gt;This release contains numerous bug fixes …&lt;/p&gt;</summary><content type="html">&lt;p&gt;The Lucene PMC is pleased to announce the release of Apache Lucene 6.4.1&lt;/p&gt;
&lt;p&gt;Apache Lucene is a high-performance, full-featured text search engine
library written entirely in Java. It is a technology suitable for nearly
any application that requires full-text search, especially cross-platform.&lt;/p&gt;
&lt;p&gt;This release contains numerous bug fixes, optimizations, and
improvements, some of which are highlighted below.
TThe release is available for immediate download at:&lt;/p&gt;
&lt;p&gt;&lt;a href="https://www.apache.org/dyn/closer.lua/lucene/java/6.4.1"&gt;https://www.apache.org/dyn/closer.lua/lucene/java/6.4.1&lt;/a&gt;&lt;/p&gt;
&lt;p&gt;See the &lt;a href="/core/6_4_1/changes/Changes.html"&gt;CHANGES.txt&lt;/a&gt; file included with the
release for a full list of changes and further details.&lt;/p&gt;
&lt;h3 id="highlights-of-this-lucene-release-include"&gt;Highlights of this Lucene release include:&lt;/h3&gt;
&lt;ul&gt;
&lt;li&gt;
&lt;p&gt;Javadocs now build successfully with Java 8u121&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;Fixed memory leak in the case that TermQuery or SpanTermQuery objects that wrap a TermContext were cached&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;Fixed native memory leak when the codec is configured with the BEST_COMPRESSION option&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;AnalyzingInfixSuggester now only opens an IndexWriter when changes need to be applied&lt;/p&gt;
&lt;/li&gt;
&lt;/ul&gt;</content><category term="core/news"></category></entry><entry><title>Apache Lucene™ 6.4.0 available</title><link href="/" rel="alternate"></link><published>2017-01-23T00:00:00+00:00</published><updated>2017-01-23T00:00:00+00:00</updated><author><name>Lucene Developers</name></author><id>tag:None,2017-01-23:/</id><summary type="html">&lt;p&gt;The Lucene PMC is pleased to announce the release of Apache Lucene 6.4.0&lt;/p&gt;
&lt;p&gt;Apache Lucene is a high-performance, full-featured text search engine
library written entirely in Java. It is a technology suitable for nearly
any application that requires full-text search, especially cross-platform.&lt;/p&gt;
&lt;p&gt;This release contains numerous bug fixes …&lt;/p&gt;</summary><content type="html">&lt;p&gt;The Lucene PMC is pleased to announce the release of Apache Lucene 6.4.0&lt;/p&gt;
&lt;p&gt;Apache Lucene is a high-performance, full-featured text search engine
library written entirely in Java. It is a technology suitable for nearly
any application that requires full-text search, especially cross-platform.&lt;/p&gt;
&lt;p&gt;This release contains numerous bug fixes, optimizations, and
improvements, some of which are highlighted below.
The release is available for immediate download at:&lt;/p&gt;
&lt;p&gt;&lt;a href="https://www.apache.org/dyn/closer.lua/lucene/java/6.4.0"&gt;https://www.apache.org/dyn/closer.lua/lucene/java/6.4.0&lt;/a&gt;&lt;/p&gt;
&lt;p&gt;See the &lt;a href="/core/6_4_0/changes/Changes.html"&gt;CHANGES.txt&lt;/a&gt; file included with the
release for a full list of changes and further details.&lt;/p&gt;
&lt;h3 id="highlights-of-this-lucene-release-include"&gt;Highlights of this Lucene release include:&lt;/h3&gt;
&lt;ul&gt;
&lt;li&gt;
&lt;p&gt;Lucene's best efforts to un-map memory mapped files with "MMapDirectory" now work with the latest Java9 early access builds&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;A new similarity "BooleanSimilarity" that gives terms a score that is equal to their query boost&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;The axiomatic family of similarities (6 in total) based on https://www.eecis.udel.edu/~hfang/pubs/sigir05-axiom.pdf&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;A new token filter "SynonymGraphFilter" that outputs a correct graph structure for multi-token synonyms at query time&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;Graph token streams, such as those produced by the "SynonymGraphFilter", are now handled accurately by query parsers&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;A new collector "DocValuesStatsCollector" gives the ability to compute statistics on DocValues field&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;It is now possible to filter "SortedDocValues" and "SortedSetDocValues" terms enum with a compiled automaton&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;The "UnifiedHighlighter" can now highlight fields with queries that don't necessarily refer to that field&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;DrillSideways can now run queries concurrently&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;Index sorting now supports sorting on multi-valued fields using MIN, MAX, etc. selectors&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;Points do not store the implicit split dimension in the 1-dimension case. This saves between 6% memory for the largest types such an InetAddressPoint to 33% for the smaller types such as HalfFloatPoint.&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;The BKD in-memory index for dimensional points now uses a compressed format, using substantially less RAM in some cases&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;The BKD writing now buffers each leaf block in heap before writing to disk, giving a small speedup in points-heavy use cases&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;"TermAutomatonQuery" now rewrites to more efficient queries when possible&lt;/p&gt;
&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;Please note, this release cannot be built from source with Java 8 update 121,
use an earlier version instead! This is caused by a bug introduced into the
Javadocs tool shipped with that update. The workaround was too late for this
Lucene release. Of course, you can use the binary artifacts.&lt;/p&gt;</content><category term="core/news"></category></entry><entry><title>Apache Lucene™ 6.3.0 available</title><link href="/" rel="alternate"></link><published>2016-11-08T00:00:00+00:00</published><updated>2016-11-08T00:00:00+00:00</updated><author><name>Lucene Developers</name></author><id>tag:None,2016-11-08:/</id><summary type="html">&lt;p&gt;The Lucene PMC is pleased to announce the release of Apache Lucene 6.3.0&lt;/p&gt;
&lt;p&gt;Apache Lucene is a high-performance, full-featured text search engine
library written entirely in Java. It is a technology suitable for nearly
any application that requires full-text search, especially cross-platform.&lt;/p&gt;
&lt;p&gt;This release contains numerous bug fixes …&lt;/p&gt;</summary><content type="html">&lt;p&gt;The Lucene PMC is pleased to announce the release of Apache Lucene 6.3.0&lt;/p&gt;
&lt;p&gt;Apache Lucene is a high-performance, full-featured text search engine
library written entirely in Java. It is a technology suitable for nearly
any application that requires full-text search, especially cross-platform.&lt;/p&gt;
&lt;p&gt;This release contains numerous bug fixes, optimizations, and
improvements, some of which are highlighted below.
The release is available for immediate download at:&lt;/p&gt;
&lt;p&gt;&lt;a href="https://www.apache.org/dyn/closer.lua/lucene/java/6.3.0"&gt;https://www.apache.org/dyn/closer.lua/lucene/java/6.3.0&lt;/a&gt;&lt;/p&gt;
&lt;p&gt;See the &lt;a href="/core/6_3_0/changes/Changes.html"&gt;CHANGES.txt&lt;/a&gt; file included with the
release for a full list of changes and further details.&lt;/p&gt;
&lt;h3 id="highlights-of-this-lucene-release-include"&gt;Highlights of this Lucene release include:&lt;/h3&gt;
&lt;ul&gt;
&lt;li&gt;
&lt;p&gt;A brand new "UnifiedHighlighter" derivative of the PostingsHighlighter that can consume offsets from postings, term vectors, or analysis. It can highlight phrases as accurately as the standard Highlighter. Light term vectors can be used with offsets in postings for fast wildcard (MultiTermQuery) highlighting.&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;SimpleQueryParser now parses '*' to MatchAllDocsQuery&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;FuzzyQuery now matches all terms within the specified edit distance, even if they are short terms&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;Points do not store the implicit split dimension in the 1-dimension case. This saves between 6% memory for the largest types such an InetAddressPoint to 33% for the smaller types such as HalfFloatPoint.&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;Many other changes and bug fixes&lt;/p&gt;
&lt;/li&gt;
&lt;/ul&gt;</content><category term="core/news"></category></entry><entry><title>Apache Lucene™ 6.2.1 available</title><link href="/" rel="alternate"></link><published>2016-09-20T00:00:00+00:00</published><updated>2016-09-20T00:00:00+00:00</updated><author><name>Lucene Developers</name></author><id>tag:None,2016-09-20:/</id><summary type="html">&lt;p&gt;The Lucene PMC is pleased to announce the release of Apache Lucene 6.2.1&lt;/p&gt;
&lt;p&gt;Apache Lucene is a high-performance, full-featured text search engine
library written entirely in Java. It is a technology suitable for nearly
any application that requires full-text search, especially cross-platform.&lt;/p&gt;
&lt;h3 id="highlights-of-this-lucene-release-include"&gt;Highlights of this Lucene release include …&lt;/h3&gt;</summary><content type="html">&lt;p&gt;The Lucene PMC is pleased to announce the release of Apache Lucene 6.2.1&lt;/p&gt;
&lt;p&gt;Apache Lucene is a high-performance, full-featured text search engine
library written entirely in Java. It is a technology suitable for nearly
any application that requires full-text search, especially cross-platform.&lt;/p&gt;
&lt;h3 id="highlights-of-this-lucene-release-include"&gt;Highlights of this Lucene release include:&lt;/h3&gt;
&lt;ul&gt;
&lt;li&gt;
&lt;p&gt;LUCENE-7417: The standard Highlighter could throw an !IllegalArgumentException when trying to highlight a query containing a degenerate case of a !MultiPhraseQuery with one term.&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;LUCENE-7440: Document id skipping (!PostingsEnum.advance) could throw an !ArrayIndexOutOfBoundsException exception on large index segments (&amp;gt;1.8B docs) with large skips.&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;LUCENE-7318: Fix backwards compatibility issues around StandardAnalyzer and its components, introduced with Lucene 6.2.0. The moved classes were restored in their original packages: LowercaseFilter and StopFilter, as well as several utility classes.&lt;/p&gt;
&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;The release is available for immediate download at:&lt;/p&gt;
&lt;p&gt;&lt;a href="https://www.apache.org/dyn/closer.lua/lucene/java/6.2.1"&gt;https://www.apache.org/dyn/closer.lua/lucene/java/6.2.1&lt;/a&gt;&lt;/p&gt;
&lt;p&gt;See the &lt;a href="/core/6_2_1/changes/Changes.html"&gt;CHANGES.txt&lt;/a&gt; file included with the
release for a full list of changes and further details.&lt;/p&gt;</content><category term="core/news"></category></entry><entry><title>Apache Lucene 5.5.3 available</title><link href="/" rel="alternate"></link><published>2016-09-09T00:00:00+00:00</published><updated>2016-09-09T00:00:00+00:00</updated><author><name>Lucene Developers</name></author><id>tag:None,2016-09-09:/</id><summary type="html">&lt;p&gt;The Lucene PMC is pleased to announce the release of Apache Lucene 5.5.3&lt;/p&gt;
&lt;p&gt;Apache Lucene is a high-performance, full-featured text search engine
library written entirely in Java. It is a technology suitable for nearly
any application that requires full-text search, especially cross-platform.&lt;/p&gt;
&lt;p&gt;The release is available for immediate …&lt;/p&gt;</summary><content type="html">&lt;p&gt;The Lucene PMC is pleased to announce the release of Apache Lucene 5.5.3&lt;/p&gt;
&lt;p&gt;Apache Lucene is a high-performance, full-featured text search engine
library written entirely in Java. It is a technology suitable for nearly
any application that requires full-text search, especially cross-platform.&lt;/p&gt;
&lt;p&gt;The release is available for immediate download at:&lt;/p&gt;
&lt;p&gt;&lt;a href="https://www.apache.org/dyn/closer.lua/lucene/java/5.5.3"&gt;https://www.apache.org/dyn/closer.lua/lucene/java/5.5.3&lt;/a&gt;&lt;/p&gt;
&lt;p&gt;See the &lt;a href="/core/5_5_3/changes/Changes.html"&gt;CHANGES.txt&lt;/a&gt; file included with the
release for a full list of changes and further details.&lt;/p&gt;</content><category term="core/news"></category></entry><entry><title>Apache Lucene 6.2.0 available</title><link href="/" rel="alternate"></link><published>2016-08-25T00:00:00+00:00</published><updated>2016-08-25T00:00:00+00:00</updated><author><name>Lucene Developers</name></author><id>tag:None,2016-08-25:/</id><summary type="html">&lt;p&gt;The Lucene PMC is pleased to announce the release of Apache Lucene 6.2.0&lt;/p&gt;
&lt;p&gt;Apache Lucene is a high-performance, full-featured text search engine
library written entirely in Java. It is a technology suitable for nearly
any application that requires full-text search, especially cross-platform.&lt;/p&gt;
&lt;p&gt;This release contains numerous bug fixes …&lt;/p&gt;</summary><content type="html">&lt;p&gt;The Lucene PMC is pleased to announce the release of Apache Lucene 6.2.0&lt;/p&gt;
&lt;p&gt;Apache Lucene is a high-performance, full-featured text search engine
library written entirely in Java. It is a technology suitable for nearly
any application that requires full-text search, especially cross-platform.&lt;/p&gt;
&lt;p&gt;This release contains numerous bug fixes, optimizations, and
improvements, some of which are highlighted below. The release
is available for immediate download at:
  https://lucene.apache.org/core/mirrors-core-latest-redir.html&lt;/p&gt;
&lt;p&gt;Please read CHANGES.txt for a full list of new features and changes:
  https://lucene.apache.org/core/6_2_0/changes/Changes.html&lt;/p&gt;
&lt;h3 id="highlights-of-this-lucene-release-include"&gt;Highlights of this Lucene release include:&lt;/h3&gt;
&lt;ul&gt;
&lt;li&gt;
&lt;p&gt;The CREATE_NEW flag is passed when creating a file to ensure Lucene is really write-once&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;Index numeric ranges (min and max value in a single field) and search by overlapping range&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;IndexWriter methods return a sequence number indicating effective order of operations across threads&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;UkrainianMorfologikAnalyzer is a new dictionary based analyzer for the Ukrainian language&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;The Polygon class can now be created from a GeoJSON string&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;Compound file creation now verifies checksum of its component files&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;Index time sorting is now a core feature, and supports dimensional points&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;StandardAnalyzer is moved to core and is the default analyzer&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;MatchNoDocsQuery now includes the reason it was created&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;QueryParser can now be told to not pre-split on whitespace&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;MMapDirectory tries harder to prevent SIGSEGV if buggy code tries to execute
    searches after the index was closed, but it's still best effort&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;MMapDirectory no longer allocates weak references to ease garbage collection&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;Conjunction (MUST, FILTER) queries are faster&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;Dimensional points have much faster (~40%) flush time and use less space in the index&lt;/p&gt;
&lt;/li&gt;
&lt;/ul&gt;</content><category term="core/news"></category></entry><entry><title>Apache Lucene 5.5.2 available</title><link href="/" rel="alternate"></link><published>2016-06-25T00:00:00+00:00</published><updated>2016-06-25T00:00:00+00:00</updated><author><name>Lucene Developers</name></author><id>tag:None,2016-06-25:/</id><summary type="html">&lt;p&gt;The Lucene PMC is pleased to announce the release of Apache Lucene 5.5.2&lt;/p&gt;
&lt;p&gt;Apache Lucene is a high-performance, full-featured text search engine
library written entirely in Java. It is a technology suitable for nearly
any application that requires full-text search, especially cross-platform.&lt;/p&gt;
&lt;p&gt;This release contains 11 bug fixes …&lt;/p&gt;</summary><content type="html">&lt;p&gt;The Lucene PMC is pleased to announce the release of Apache Lucene 5.5.2&lt;/p&gt;
&lt;p&gt;Apache Lucene is a high-performance, full-featured text search engine
library written entirely in Java. It is a technology suitable for nearly
any application that requires full-text search, especially cross-platform.&lt;/p&gt;
&lt;p&gt;This release contains 11 bug fixes since the 5.5.1 release.&lt;/p&gt;
&lt;p&gt;The release is available for immediate download at:&lt;/p&gt;
&lt;p&gt;&lt;a href="https://www.apache.org/dyn/closer.lua/lucene/java/5.5.2"&gt;https://www.apache.org/dyn/closer.lua/lucene/java/5.5.2&lt;/a&gt;&lt;/p&gt;
&lt;p&gt;See the &lt;a href="/core/5_5_2/changes/Changes.html"&gt;CHANGES.txt&lt;/a&gt; file included with the
release for a full list of changes and further details.&lt;/p&gt;</content><category term="core/news"></category></entry><entry><title>Apache Lucene 6.1.0 available</title><link href="/" rel="alternate"></link><published>2016-06-17T00:00:00+00:00</published><updated>2016-06-17T00:00:00+00:00</updated><author><name>Lucene Developers</name></author><id>tag:None,2016-06-17:/</id><summary type="html">&lt;p&gt;The Lucene PMC is pleased to announce the release of Apache Lucene 6.1.0.&lt;/p&gt;
&lt;p&gt;Apache Lucene is a high-performance, full-featured text search engine
library written entirely in Java. It is a technology suitable for nearly
any application that requires full-text search, especially cross-platform.&lt;/p&gt;
&lt;p&gt;This release contains numerous bug fixes …&lt;/p&gt;</summary><content type="html">&lt;p&gt;The Lucene PMC is pleased to announce the release of Apache Lucene 6.1.0.&lt;/p&gt;
&lt;p&gt;Apache Lucene is a high-performance, full-featured text search engine
library written entirely in Java. It is a technology suitable for nearly
any application that requires full-text search, especially cross-platform.&lt;/p&gt;
&lt;p&gt;This release contains numerous bug fixes, optimizations, and
improvements, some of which are highlighted below. The release
is available for immediate download at:
  https://lucene.apache.org/core/mirrors-core-latest-redir.html&lt;/p&gt;
&lt;p&gt;Please read CHANGES.txt for a full list of new features and changes:
  https://lucene.apache.org/core/6_1_0/changes/Changes.html&lt;/p&gt;
&lt;p&gt;Lucene 6.1.0 Release Highlights:&lt;/p&gt;
&lt;p&gt;New features&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;
&lt;p&gt;Numerous improvements to LatLonPoint, for indexing a latitude/longitude point and searching by polygon, distance or box, or finding nearest neighbors&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;Geo3D now has simple APIs for creating common shape queries, matching LatLonPoint&lt;/p&gt;
&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;Optimizations&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;
&lt;p&gt;Faster indexing and searching of points.&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;Faster geo-spatial indexing and searching for LatLonPoint, Geo3D and GeoPoint (see http://home.apache.org/~mikemccand/geobench.html )&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;HardlinkCopyDirectoryWrapper optimizes file copies using hard links&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;In case of contention, the query cache now prefers returning an uncached Scorer rather than waiting on a lock.&lt;/p&gt;
&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;Bug fixes&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;
&lt;p&gt;BooleanQuery could sometimes assign too low scores to ranges of documents that matched a single clause.&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;Doc values updates could sometimes be applied in the wrong order.&lt;/p&gt;
&lt;/li&gt;
&lt;/ul&gt;</content><category term="core/news"></category></entry><entry><title>Apache Lucene 6.0.1 available</title><link href="/" rel="alternate"></link><published>2016-05-28T00:00:00+00:00</published><updated>2016-05-28T00:00:00+00:00</updated><author><name>Lucene Developers</name></author><id>tag:None,2016-05-28:/</id><summary type="html">&lt;p&gt;The Lucene PMC is pleased to announce the release of Apache Lucene 6.0.1&lt;/p&gt;
&lt;p&gt;Apache Lucene is a high-performance, full-featured text search engine
library written entirely in Java. It is a technology suitable for nearly
any application that requires full-text search, especially cross-platform.&lt;/p&gt;
&lt;p&gt;This release contains 10 bug fixes …&lt;/p&gt;</summary><content type="html">&lt;p&gt;The Lucene PMC is pleased to announce the release of Apache Lucene 6.0.1&lt;/p&gt;
&lt;p&gt;Apache Lucene is a high-performance, full-featured text search engine
library written entirely in Java. It is a technology suitable for nearly
any application that requires full-text search, especially cross-platform.&lt;/p&gt;
&lt;p&gt;This release contains 10 bug fixes since the 6.0.0 release, and one new feature:&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;Spatial-extras DateRangePrefixTree's Calendar is now configurable, to e.g. clear the Gregorian Change Date. Also, toString(cal) is now identical to DateTimeFormatter.ISO_INSTANT.&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;The release is available for immediate download at:&lt;/p&gt;
&lt;p&gt;&lt;a href="https://www.apache.org/dyn/closer.lua/lucene/java/6.0.1"&gt;https://www.apache.org/dyn/closer.lua/lucene/java/6.0.1&lt;/a&gt;&lt;/p&gt;
&lt;p&gt;See the &lt;a href="/core/6_0_1/changes/Changes.html"&gt;CHANGES.txt&lt;/a&gt; file included with the
release for a full list of changes and further details.&lt;/p&gt;</content><category term="core/news"></category></entry><entry><title>Apache Lucene 5.5.1 Available</title><link href="/" rel="alternate"></link><published>2016-05-05T00:00:00+00:00</published><updated>2016-05-05T00:00:00+00:00</updated><author><name>Lucene Developers</name></author><id>tag:None,2016-05-05:/</id><summary type="html">&lt;p&gt;The Lucene PMC is pleased to announce the release of Apache Lucene 5.5.1&lt;/p&gt;
&lt;p&gt;Apache Lucene is a high-performance, full-featured text search engine
library written entirely in Java. It is a technology suitable for nearly
any application that requires full-text search, especially cross-platform.&lt;/p&gt;
&lt;p&gt;This release contains one bug fix …&lt;/p&gt;</summary><content type="html">&lt;p&gt;The Lucene PMC is pleased to announce the release of Apache Lucene 5.5.1&lt;/p&gt;
&lt;p&gt;Apache Lucene is a high-performance, full-featured text search engine
library written entirely in Java. It is a technology suitable for nearly
any application that requires full-text search, especially cross-platform.&lt;/p&gt;
&lt;p&gt;This release contains one bug fix since the 5.5.0 release. The release
is available for immediate download at:&lt;/p&gt;
&lt;p&gt;&lt;a href="https://www.apache.org/dyn/closer.lua/lucene/core/5.5.1"&gt;https://www.apache.org/dyn/closer.lua/lucene/core/5.5.1&lt;/a&gt;&lt;/p&gt;
&lt;p&gt;See the &lt;a href="/core/5_5_1/changes/Changes.html"&gt;CHANGES.txt&lt;/a&gt; file included with the
release for a full list of changes and further details.&lt;/p&gt;</content><category term="core/news"></category></entry><entry><title>Apache Lucene 6.0.0 Available</title><link href="/" rel="alternate"></link><published>2016-04-08T00:00:00+00:00</published><updated>2016-04-08T00:00:00+00:00</updated><author><name>Lucene Developers</name></author><id>tag:None,2016-04-08:/</id><summary type="html">&lt;p&gt;The Lucene PMC is pleased to announce the release of Apache Lucene 6.0.0.&lt;/p&gt;
&lt;p&gt;The release can be downloaded from &lt;a href="https://lucene.apache.org/core/mirrors-core-latest-redir.html"&gt;https://lucene.apache.org/core/mirrors-core-latest-redir.html&lt;/a&gt;&lt;/p&gt;
&lt;p&gt;Release Highlights:&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;
&lt;p&gt;Java 8 is the minimum Java version required.&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;Dimensional points, replacing legacy numeric fields, provides fast and space-efficient support for …&lt;/p&gt;&lt;/li&gt;&lt;/ul&gt;</summary><content type="html">&lt;p&gt;The Lucene PMC is pleased to announce the release of Apache Lucene 6.0.0.&lt;/p&gt;
&lt;p&gt;The release can be downloaded from &lt;a href="https://lucene.apache.org/core/mirrors-core-latest-redir.html"&gt;https://lucene.apache.org/core/mirrors-core-latest-redir.html&lt;/a&gt;&lt;/p&gt;
&lt;p&gt;Release Highlights:&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;
&lt;p&gt;Java 8 is the minimum Java version required.&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;Dimensional points, replacing legacy numeric fields, provides fast and space-efficient support for both single- and multi-dimension range and shape filtering.  This includes numeric (int, float, long, double), InetAddress, BigInteger and binary range filtering, as well as geo-spatial shape search over indexed 2D LatLonPoints.  See &lt;a href="https://www.elastic.co/blog/lucene-points-6.0"&gt;this blog post&lt;/a&gt; for details.  Dependent classes and modules (e.g., MemoryIndex, Spatial Strategies, Join module) have been refactored to use new point types.&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;Lucene classification module now works on Lucene Documents using a KNearestNeighborClassifier or SimpleNaiveBayesClassifier.&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;The spatial module no longer depends on third-party libraries. Previous spatial classes have been moved to a new spatial-extras module.&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;Spatial4j has been updated to a new 0.6 version hosted by locationtech.&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;TermsQuery performance boost by a more aggressive default query caching policy.&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;IndexSearcher's default Similarity is now changed to BM25Similarity.&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;Easier method of defining custom CharTokenizer instances.&lt;/p&gt;
&lt;/li&gt;
&lt;/ul&gt;</content><category term="core/news"></category></entry><entry><title>Apache Lucene 5.5.0 Available</title><link href="/" rel="alternate"></link><published>2016-02-22T00:00:00+00:00</published><updated>2016-02-22T00:00:00+00:00</updated><author><name>Lucene Developers</name></author><id>tag:None,2016-02-22:/</id><summary type="html">&lt;p&gt;The Lucene PMC is pleased to announce the release of Apache Lucene 5.5.0&lt;/p&gt;
&lt;p&gt;The release can be downloaded from &lt;a href="https://lucene.apache.org/core/mirrors-core-latest-redir.html"&gt;https://lucene.apache.org/core/mirrors-core-latest-redir.html&lt;/a&gt;&lt;/p&gt;
&lt;p&gt;Release highlights:&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;
&lt;p&gt;JoinUtil.createJoinQuery can now join on numeric doc values fields&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;BlendedInfixSuggester now has an exponential reciprocal scoring model, to more …&lt;/p&gt;&lt;/li&gt;&lt;/ul&gt;</summary><content type="html">&lt;p&gt;The Lucene PMC is pleased to announce the release of Apache Lucene 5.5.0&lt;/p&gt;
&lt;p&gt;The release can be downloaded from &lt;a href="https://lucene.apache.org/core/mirrors-core-latest-redir.html"&gt;https://lucene.apache.org/core/mirrors-core-latest-redir.html&lt;/a&gt;&lt;/p&gt;
&lt;p&gt;Release highlights:&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;
&lt;p&gt;JoinUtil.createJoinQuery can now join on numeric doc values fields&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;BlendedInfixSuggester now has an exponential reciprocal scoring model, to more strongly favor suggestions with matches closer to the beginning&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;CustomAnalyzer has improved (compile time) type safety&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;DFISimilarity implements the divergence from independence scoring model&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;Fully wrap any other merge policy using MergePolicyWrapper&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;Sandbox geo point queries have graduated into the spatial module, and now use a more efficient binary term encoding for smaller index size, faster indexing, and decreased search-time heap usage&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;BooleanQuery performs some new query optimizations&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;TermsQuery constructors are more GC efficient&lt;/p&gt;
&lt;/li&gt;
&lt;/ul&gt;</content><category term="core/news"></category></entry><entry><title>Apache Lucene 5.3.2 Available</title><link href="/" rel="alternate"></link><published>2016-01-23T00:00:00+00:00</published><updated>2016-01-23T00:00:00+00:00</updated><author><name>Lucene Developers</name></author><id>tag:None,2016-01-23:/</id><summary type="html">&lt;p&gt;The Lucene PMC is pleased to announce the release of Apache Lucene 5.3.2&lt;/p&gt;
&lt;p&gt;Apache Lucene is a high-performance, full-featured text search engine
library written entirely in Java. It is a technology suitable for nearly
any application that requires full-text search, especially cross-platform.&lt;/p&gt;
&lt;p&gt;This release contains one bug fix …&lt;/p&gt;</summary><content type="html">&lt;p&gt;The Lucene PMC is pleased to announce the release of Apache Lucene 5.3.2&lt;/p&gt;
&lt;p&gt;Apache Lucene is a high-performance, full-featured text search engine
library written entirely in Java. It is a technology suitable for nearly
any application that requires full-text search, especially cross-platform.&lt;/p&gt;
&lt;p&gt;This release contains one bug fix since the 5.3.1 release. The release
is available for immediate download at:&lt;/p&gt;
&lt;p&gt;&lt;a href="https://www.apache.org/dyn/closer.lua/lucene/core/5.3.2"&gt;https://www.apache.org/dyn/closer.lua/lucene/core/5.3.2&lt;/a&gt;&lt;/p&gt;
&lt;p&gt;See the &lt;a href="/core/5_3_2/changes/Changes.html"&gt;CHANGES.txt&lt;/a&gt; file included with the
release for a full list of changes and further details.&lt;/p&gt;</content><category term="core/news"></category></entry><entry><title>Apache Lucene 5.4.1 Available</title><link href="/" rel="alternate"></link><published>2016-01-23T00:00:00+00:00</published><updated>2016-01-23T00:00:00+00:00</updated><author><name>Lucene Developers</name></author><id>tag:None,2016-01-23:/</id><summary type="html">&lt;p&gt;The Lucene PMC is pleased to announce the release of Apache Lucene 5.4.1&lt;/p&gt;
&lt;p&gt;The release can be downloaded from &lt;a href="https://lucene.apache.org/core/mirrors-core-latest-redir.html"&gt;https://lucene.apache.org/core/mirrors-core-latest-redir.html&lt;/a&gt;&lt;/p&gt;
&lt;p&gt;This release contains an important fix for a corruption bug that was
introduced in version 5.4.0. If you are on …&lt;/p&gt;</summary><content type="html">&lt;p&gt;The Lucene PMC is pleased to announce the release of Apache Lucene 5.4.1&lt;/p&gt;
&lt;p&gt;The release can be downloaded from &lt;a href="https://lucene.apache.org/core/mirrors-core-latest-redir.html"&gt;https://lucene.apache.org/core/mirrors-core-latest-redir.html&lt;/a&gt;&lt;/p&gt;
&lt;p&gt;This release contains an important fix for a corruption bug that was
introduced in version 5.4.0. If you are on 5.4.0 and using BINARY,
SORTED_NUMERIC or SORTED_SET doc values, upgrading to 5.4.1 is strongly
recommended.&lt;/p&gt;
&lt;p&gt;See the &lt;a href="/core/5_4_1/changes/Changes.html"&gt;CHANGES.txt&lt;/a&gt; file included with the
release for a full list of changes and further details.&lt;/p&gt;</content><category term="core/news"></category></entry><entry><title>Apache Lucene 5.4.0 Available</title><link href="/" rel="alternate"></link><published>2015-12-14T00:00:00+00:00</published><updated>2015-12-14T00:00:00+00:00</updated><author><name>Lucene Developers</name></author><id>tag:None,2015-12-14:/</id><summary type="html">&lt;p&gt;The Lucene PMC is pleased to announce the release of Apache Lucene 5.4.0&lt;/p&gt;
&lt;p&gt;The release can be downloaded from &lt;a href="https://lucene.apache.org/core/mirrors-core-latest-redir.html"&gt;https://lucene.apache.org/core/mirrors-core-latest-redir.html&lt;/a&gt;&lt;/p&gt;
&lt;h3 id="highlights-of-this-lucene-release-include"&gt;Highlights of this Lucene release include:&lt;/h3&gt;
&lt;h4 id="api-changes"&gt;API Changes&lt;/h4&gt;
&lt;ul&gt;
&lt;li&gt;Query.getBoost and Query.setBoost are deprecated in favour of the new BoostQuery&lt;/li&gt;
&lt;li&gt;The …&lt;/li&gt;&lt;/ul&gt;</summary><content type="html">&lt;p&gt;The Lucene PMC is pleased to announce the release of Apache Lucene 5.4.0&lt;/p&gt;
&lt;p&gt;The release can be downloaded from &lt;a href="https://lucene.apache.org/core/mirrors-core-latest-redir.html"&gt;https://lucene.apache.org/core/mirrors-core-latest-redir.html&lt;/a&gt;&lt;/p&gt;
&lt;h3 id="highlights-of-this-lucene-release-include"&gt;Highlights of this Lucene release include:&lt;/h3&gt;
&lt;h4 id="api-changes"&gt;API Changes&lt;/h4&gt;
&lt;ul&gt;
&lt;li&gt;Query.getBoost and Query.setBoost are deprecated in favour of the new BoostQuery&lt;/li&gt;
&lt;li&gt;The Filter class is deprecated in favour of FILTER clauses in a BooleanQuery&lt;/li&gt;
&lt;li&gt;DefaultSimilarity has been renamed to ClassicSimilarity to prepare for the move to BM25 in Lucene 6&lt;/li&gt;
&lt;/ul&gt;
&lt;h4 id="new-features"&gt;New features&lt;/h4&gt;
&lt;ul&gt;
&lt;li&gt;New Serbian token filter&lt;/li&gt;
&lt;li&gt;New DecimalDigitFilter, to fold unicode digits to latin digits&lt;/li&gt;
&lt;li&gt;New UnicodeWhitespaceTokenizer, that uses Unicode's whitespace definition and splits on NBSP&lt;/li&gt;
&lt;li&gt;New GeoPointDistanceRangeQuery to search for geo-points within a ring&lt;/li&gt;
&lt;li&gt;Query caching is now enabled by default in IndexSearcher, use IndexSearcher.setQueryCache(null) to disable&lt;/li&gt;
&lt;/ul&gt;
&lt;h4 id="optimizations"&gt;Optimizations&lt;/h4&gt;
&lt;ul&gt;
&lt;li&gt;MatchAllDocsQuery got faster&lt;/li&gt;
&lt;li&gt;Doc values now use less memory for multi-valued fields and less disk in case of sparse fields&lt;/li&gt;
&lt;li&gt;Two-phase iterators got a match cost API so that the costly bits can be checked last&lt;/li&gt;
&lt;/ul&gt;
&lt;h4 id="bug-fixes"&gt;Bug fixes&lt;/h4&gt;
&lt;ul&gt;
&lt;li&gt;PatternTokenizer no longer hangs onto heap sized to the maximum input string it's ever seen.&lt;/li&gt;
&lt;/ul&gt;</content><category term="core/news"></category></entry><entry><title>Apache Lucene 5.3.1 and Apache Solr 5.3.1 Available</title><link href="/" rel="alternate"></link><published>2015-09-24T00:00:00+00:00</published><updated>2015-09-24T00:00:00+00:00</updated><author><name>Lucene Developers</name></author><id>tag:None,2015-09-24:/</id><summary type="html">&lt;p&gt;The Lucene PMC is pleased to announce the release of Apache Lucene 5.3.1&lt;/p&gt;
&lt;p&gt;The release can be downloaded from &lt;a href="https://lucene.apache.org/core/mirrors-core-latest-redir.html"&gt;https://lucene.apache.org/core/mirrors-core-latest-redir.html&lt;/a&gt;&lt;/p&gt;
&lt;h3 id="highlights-of-this-lucene-release-include"&gt;Highlights of this Lucene release include:&lt;/h3&gt;
&lt;h4 id="bug-fixes"&gt;Bug Fixes&lt;/h4&gt;
&lt;ul&gt;
&lt;li&gt;Remove classloader hack in MorfologikFilter&lt;/li&gt;
&lt;li&gt;UsageTrackingQueryCachingPolicy no longer caches trivial queries like MatchAllDocsQuery&lt;/li&gt;
&lt;li&gt;Fixed …&lt;/li&gt;&lt;/ul&gt;</summary><content type="html">&lt;p&gt;The Lucene PMC is pleased to announce the release of Apache Lucene 5.3.1&lt;/p&gt;
&lt;p&gt;The release can be downloaded from &lt;a href="https://lucene.apache.org/core/mirrors-core-latest-redir.html"&gt;https://lucene.apache.org/core/mirrors-core-latest-redir.html&lt;/a&gt;&lt;/p&gt;
&lt;h3 id="highlights-of-this-lucene-release-include"&gt;Highlights of this Lucene release include:&lt;/h3&gt;
&lt;h4 id="bug-fixes"&gt;Bug Fixes&lt;/h4&gt;
&lt;ul&gt;
&lt;li&gt;Remove classloader hack in MorfologikFilter&lt;/li&gt;
&lt;li&gt;UsageTrackingQueryCachingPolicy no longer caches trivial queries like MatchAllDocsQuery&lt;/li&gt;
&lt;li&gt;Fixed BoostingQuery to rewrite wrapped queries&lt;/li&gt;
&lt;/ul&gt;</content><category term="core/news"></category></entry><entry><title>Apache Lucene™ 5.3.0 available</title><link href="/" rel="alternate"></link><published>2015-08-24T00:00:00+00:00</published><updated>2015-08-24T00:00:00+00:00</updated><author><name>Lucene Developers</name></author><id>tag:None,2015-08-24:/</id><summary type="html">&lt;p&gt;The Lucene PMC is pleased to announce the release of Apache Lucene 5.3.0&lt;/p&gt;
&lt;p&gt;Apache Lucene is a high-performance, full-featured text search engine
library written entirely in Java. It is a technology suitable for nearly
any application that requires full-text search, especially cross-platform.&lt;/p&gt;
&lt;p&gt;The release is available for immediate …&lt;/p&gt;</summary><content type="html">&lt;p&gt;The Lucene PMC is pleased to announce the release of Apache Lucene 5.3.0&lt;/p&gt;
&lt;p&gt;Apache Lucene is a high-performance, full-featured text search engine
library written entirely in Java. It is a technology suitable for nearly
any application that requires full-text search, especially cross-platform.&lt;/p&gt;
&lt;p&gt;The release is available for immediate download at:
 &lt;a href="https://www.apache.org/dyn/closer.lua/lucene/java/5.3.0"&gt;https://www.apache.org/dyn/closer.lua/lucene/java/5.3.0&lt;/a&gt;&lt;/p&gt;
&lt;p&gt;This release contains numerous bug fixes, optimizations, and
improvements, some of which are highlighted below. The release
is available for immediate download at:
  https://lucene.apache.org/core/mirrors-core-latest-redir.html&lt;/p&gt;
&lt;h3 id="lucene-530-release-highlights"&gt;Lucene 5.3.0 Release Highlights:&lt;/h3&gt;
&lt;h4 id="api-changes"&gt;API Changes&lt;/h4&gt;
&lt;ul&gt;
&lt;li&gt;PhraseQuery and BooleanQuery are now immutable&lt;/li&gt;
&lt;/ul&gt;
&lt;h4 id="new-features"&gt;New features&lt;/h4&gt;
&lt;ul&gt;
&lt;li&gt;Added a new org.apache.lucene.search.join.CheckJoinIndex class that can be used to validate that an index has an appropriate structure to run join queries&lt;/li&gt;
&lt;li&gt;Added a new BlendedTermQuery to blend statistics across several terms&lt;/li&gt;
&lt;li&gt;New common suggest API that mirrors Lucene's Query/IndexSearcher APIs for Document based suggester.&lt;/li&gt;
&lt;li&gt;IndexWriter can now be initialized from an already open near-real-time or non-NRT reader&lt;/li&gt;
&lt;li&gt;Add experimental range tree doc values format and queries, based on a 1D version of the spatial BKD tree, for a faster and smaller alternative to postings-based numeric and binary term filtering.  Range trees can also handle values larger than 64 bits.&lt;/li&gt;
&lt;/ul&gt;
&lt;h4 id="geo-related-features-and-improvements"&gt;Geo-related features and improvements&lt;/h4&gt;
&lt;ul&gt;
&lt;li&gt;Added GeoPointField, GeoPointInBBoxQuery, GeoPointInPolygonQuery for simple "indexed lat/lon point in bbox/shape" searching&lt;/li&gt;
&lt;li&gt;Added experimental BKD geospatial tree doc values format and queries, for fast "bbox/polygon contains lat/lon points"&lt;/li&gt;
&lt;li&gt;Use doc values to post-filter GeoPointField hits that fall in boundary cells, resulting in smaller index, faster searches and less heap used for each query&lt;/li&gt;
&lt;/ul&gt;
&lt;h4 id="optimizations"&gt;Optimizations&lt;/h4&gt;
&lt;ul&gt;
&lt;li&gt;Reduce RAM usage of FieldInfos, and speed up lookup by number, by using an array instead of TreeMap except in very sparse cases&lt;/li&gt;
&lt;li&gt;Faster intersection of the terms dictionary with very finite automata, which can be generated eg. by simple regexp queries&lt;/li&gt;
&lt;li&gt;Various bugfixes and optimizations since the 5.2.0 release.&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;See the &lt;a href="/core/5_3_0/changes/Changes.html"&gt;CHANGES.txt&lt;/a&gt; file included with the
release for a full list of changes and further details.&lt;/p&gt;</content><category term="core/news"></category></entry><entry><title>Apache Lucene™ 5.2.1 available</title><link href="/" rel="alternate"></link><published>2015-06-15T00:00:00+00:00</published><updated>2015-06-15T00:00:00+00:00</updated><author><name>Lucene Developers</name></author><id>tag:None,2015-06-15:/</id><summary type="html">&lt;p&gt;The Lucene PMC is pleased to announce the release of Apache Lucene 5.2.1&lt;/p&gt;
&lt;p&gt;Apache Lucene is a high-performance, full-featured text search engine library written entirely in Java. It is a technology suitable for nearly any application that requires full-text search, especially cross-platform.&lt;/p&gt;
&lt;p&gt;This release contains various bug fixes …&lt;/p&gt;</summary><content type="html">&lt;p&gt;The Lucene PMC is pleased to announce the release of Apache Lucene 5.2.1&lt;/p&gt;
&lt;p&gt;Apache Lucene is a high-performance, full-featured text search engine library written entirely in Java. It is a technology suitable for nearly any application that requires full-text search, especially cross-platform.&lt;/p&gt;
&lt;p&gt;This release contains various bug fixes and optimizations since the 5.2.0 release.&lt;/p&gt;
&lt;p&gt;The release is available for immediate download at:
 &lt;a href="https://www.apache.org/dyn/closer.lua/lucene/java/5.2.1"&gt;https://www.apache.org/dyn/closer.lua/lucene/java/5.2.1&lt;/a&gt;&lt;/p&gt;
&lt;p&gt;Lucene 5.2.1 includes 3 bug fixes:&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;Fix class loading deadlock relating to Codec initialization, default codec and SPI discovery.&lt;/li&gt;
&lt;li&gt;NRT readers now reflect a new commit even if there is no change to the commit user data&lt;/li&gt;
&lt;li&gt;Queries now get a dummy Similarity when scores are not needed in order to not load unnecessary information like norms&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;See the &lt;a href="/core/5_2_1/changes/Changes.html"&gt;CHANGES.txt&lt;/a&gt; file included with the
release for a full list of changes and further details.&lt;/p&gt;</content><category term="core/news"></category></entry><entry><title>Lucene Core 5.2.0 Available</title><link href="/" rel="alternate"></link><published>2015-06-07T00:00:00+00:00</published><updated>2015-06-07T00:00:00+00:00</updated><author><name>Lucene Developers</name></author><id>tag:None,2015-06-07:/</id><summary type="html">&lt;p&gt;The Lucene PMC is pleased to announce the release of Apache Lucene 5.2.0&lt;/p&gt;
&lt;p&gt;Apache Lucene is a high-performance, full-featured text search engine
library written entirely in Java. It is a technology suitable for nearly
any application that requires full-text search, especially cross-platform.&lt;/p&gt;
&lt;p&gt;The release is available for immediate …&lt;/p&gt;</summary><content type="html">&lt;p&gt;The Lucene PMC is pleased to announce the release of Apache Lucene 5.2.0&lt;/p&gt;
&lt;p&gt;Apache Lucene is a high-performance, full-featured text search engine
library written entirely in Java. It is a technology suitable for nearly
any application that requires full-text search, especially cross-platform.&lt;/p&gt;
&lt;p&gt;The release is available for immediate download at:
 &lt;a href="https://www.apache.org/dyn/closer.lua/lucene/java/5.2.0"&gt;https://www.apache.org/dyn/closer.lua/lucene/java/5.2.0&lt;/a&gt;&lt;/p&gt;
&lt;p&gt;Lucene 5.2.0 release highlights:&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;
&lt;p&gt;Span queries now share document conjunction/intersection code with boolean queries, and use two-phased iterators for faster intersection by avoiding loading positions in certain cases.&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;Added two-phase support to SpanNotQuery, and SpanPositionCheckQuery and its subclasses: SpanPositionRangeQuery, SpanPayloadCheckQuery, SpanNearPayloadCheckQuery, SpanFirstQuery.&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;Added a new query time join to the join module that uses global ordinals, which is faster for subsequent joins between reopens.&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;New CompositeSpatialStrategy combines speed of RPT with accuracy of SDV. Includes optimized Intersect predicate to avoid many geometry checks. Uses TwoPhaseIterator.&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;New LimitTokenOffsetFilter that limits tokens to those before a configured maximum start offset.&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;New spatial PackedQuadPrefixTree, a generally more efficient choice than QuadPrefixTree, especially for high precision shapes. When used, you should typically disable RPT's pruneLeafyBranches option.&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;Expressions now support bindings keys that look like zero arg functions&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;Add SpanWithinQuery and SpanContainingQuery that return spans inside of / containing another spans.&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;New Spatial "Geo3d" API with partial Spatial4j integration. It is a set of shapes implemented using 3D planar geometry for calculating spatial relations on the surface of a sphere. Shapes include Point, BBox, Circle, Path (buffered line string), and Polygon.&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;Various bugfixes and optimizations since the 5.1.0 release.&lt;/p&gt;
&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;See the &lt;a href="/core/5_2_0/changes/Changes.html"&gt;CHANGES.txt&lt;/a&gt; file included with the
release for a full list of changes and further details.&lt;/p&gt;</content><category term="core/news"></category></entry><entry><title>Lucene Core 5.1.0 Available</title><link href="/" rel="alternate"></link><published>2015-04-14T00:00:00+00:00</published><updated>2015-04-14T00:00:00+00:00</updated><author><name>Lucene Developers</name></author><id>tag:None,2015-04-14:/</id><summary type="html">&lt;p&gt;The Lucene PMC is pleased to announce the release of Apache Lucene 5.1.0&lt;/p&gt;
&lt;p&gt;Apache Lucene is a high-performance, full-featured text search engine
library written entirely in Java. It is a technology suitable for nearly
any application that requires full-text search, especially cross-platform.&lt;/p&gt;
&lt;p&gt;The release is available for immediate …&lt;/p&gt;</summary><content type="html">&lt;p&gt;The Lucene PMC is pleased to announce the release of Apache Lucene 5.1.0&lt;/p&gt;
&lt;p&gt;Apache Lucene is a high-performance, full-featured text search engine
library written entirely in Java. It is a technology suitable for nearly
any application that requires full-text search, especially cross-platform.&lt;/p&gt;
&lt;p&gt;The release is available for immediate download at:
 &lt;a href="https://www.apache.org/dyn/closer.lua/lucene/java/5.1.0"&gt;https://www.apache.org/dyn/closer.lua/lucene/java/5.1.0&lt;/a&gt;&lt;/p&gt;
&lt;p&gt;Lucene 5.1.0 includes 9 new features, 10 bug fixes, and 24 optimizations / other
changes from 18 unique contributors.&lt;/p&gt;
&lt;p&gt;See the &lt;a href="/core/5_1_0/changes/Changes.html"&gt;CHANGES.txt&lt;/a&gt; file included with the
release for a full list of changes and further details.&lt;/p&gt;</content><category term="core/news"></category></entry><entry><title>Lucene Core 4.10.4 Available</title><link href="/" rel="alternate"></link><published>2015-03-05T00:00:00+00:00</published><updated>2015-03-05T00:00:00+00:00</updated><author><name>Lucene Developers</name></author><id>tag:None,2015-03-05:/</id><summary type="html">&lt;p&gt;The Lucene PMC is pleased to announce the release of Apache Lucene 4.10.4&lt;/p&gt;
&lt;p&gt;Apache Lucene is a high-performance, full-featured text search engine
library written entirely in Java. It is a technology suitable for nearly
any application that requires full-text search, especially cross-platform.&lt;/p&gt;
&lt;p&gt;The release is available for immediate …&lt;/p&gt;</summary><content type="html">&lt;p&gt;The Lucene PMC is pleased to announce the release of Apache Lucene 4.10.4&lt;/p&gt;
&lt;p&gt;Apache Lucene is a high-performance, full-featured text search engine
library written entirely in Java. It is a technology suitable for nearly
any application that requires full-text search, especially cross-platform.&lt;/p&gt;
&lt;p&gt;The release is available for immediate download at:
 &lt;a href="https://www.apache.org/dyn/closer.lua/lucene/java/4.10.4"&gt;https://www.apache.org/dyn/closer.lua/lucene/java/4.10.4&lt;/a&gt;&lt;/p&gt;
&lt;p&gt;Lucene 4.10.4 includes 13 bug fixes.&lt;/p&gt;
&lt;p&gt;See the &lt;a href="/core/4_10_4/changes/Changes.html"&gt;CHANGES.txt&lt;/a&gt; file included with the
release for a full list of changes and further details.&lt;/p&gt;</content><category term="core/news"></category></entry><entry><title>Lucene™ 5.0.0 core available</title><link href="/" rel="alternate"></link><published>2015-02-20T00:00:00+00:00</published><updated>2015-02-20T00:00:00+00:00</updated><author><name>Lucene Developers</name></author><id>tag:None,2015-02-20:/</id><summary type="html">&lt;p&gt;The Lucene PMC is pleased to announce the release of Apache Lucene 5.0.&lt;/p&gt;
&lt;p&gt;Apache Lucene is a high-performance, full-featured text search engine
library written entirely in Java. It is a technology suitable for nearly
any application that requires full-text search, especially cross-platform.&lt;/p&gt;
&lt;p&gt;This release contains numerous bug fixes, optimizations …&lt;/p&gt;</summary><content type="html">&lt;p&gt;The Lucene PMC is pleased to announce the release of Apache Lucene 5.0.&lt;/p&gt;
&lt;p&gt;Apache Lucene is a high-performance, full-featured text search engine
library written entirely in Java. It is a technology suitable for nearly
any application that requires full-text search, especially cross-platform.&lt;/p&gt;
&lt;p&gt;This release contains numerous bug fixes, optimizations, and
improvements, some of which are highlighted below. The release
is available for immediate download at:
&lt;a href="https://lucene.apache.org/core/mirrors-core-latest-redir.html"&gt;https://lucene.apache.org/core/mirrors-core-latest-redir.html&lt;/a&gt;&lt;/p&gt;
&lt;p&gt;Lucene 5.0 Release Highlights:&lt;/p&gt;
&lt;p&gt;Stronger index safety&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;
&lt;p&gt;All file access now uses Java’s NIO.2 APIs which give Lucene stronger index safety in terms of better error handling and safer commits.&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;Every Lucene segment now stores a unique id per-segment and per-commit to aid in accurate replication of index files.&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;During merging, IndexWriter now always checks the incoming segments for corruption before merging. This can mean, on upgrading to 5.0.0, that merging may uncover long-standing latent corruption in an older 4.x index.&lt;/p&gt;
&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;Reduced heap usage&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;
&lt;p&gt;Lucene now supports random-writable and advance-able sparse bitsets (RoaringDocIdSet and SparseFixedBitSet), so the heap required is in proportion to how many bits are set, not how many total documents exist in the index.&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;Heap usage during IndexWriter merging is also much lower with the new Lucene50Codec, since doc values and norms for the segments being merged are no longer fully loaded into heap for all fields; now they are loaded for the one field currently being merged, and then dropped.&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;The default norms format now uses sparse encoding when appropriate, so indices that enable norms for many sparse fields will see a large reduction in required heap at search time.&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;5.0 has a new API to print a tree structure showing a recursive breakdown of which parts are using how much heap.&lt;/p&gt;
&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;Other features&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;
&lt;p&gt;FieldCache is gone (moved to a dedicated UninvertingReader in the misc module). This means when you intend to sort on a field, you should index that field using doc values, which is much faster and less heap consuming than FieldCache.&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;Tokenizers and Analyzers no longer require Reader on init.&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;NormsFormat now gets its own dedicated NormsConsumer/Producer&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;SortedSetSortField, used to sort on a multi-valued field, is promoted from sandbox to Lucene's core.&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;PostingsFormat now uses a "pull" API when writing postings, just like doc values. This is powerful because you can do things in your postings format that require making more than one pass through the postings such as iterating over all postings for each term to decide which compression format it should use.&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;New DateRangeField type enables Indexing and searching of date ranges, particularly multi-valued ones.&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;A new ExitableDirectoryReader extends FilterDirectoryReader and enables exiting requests that take too long to enumerate over terms.&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;Suggesters from multi-valued field can now be built as DocumentDictionary now enumerates each value separately in a multi-valued field.&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;ConcurrentMergeScheduler detects whether the index is on SSD or not and does a better job defaulting its settings. This only works on Linux for now; other OS's will continue to use the previous defaults (tuned for spinning disks).&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;Auto-IO-throttling has been added to ConcurrentMergeScheduler, to rate limit IO writes for each merge depending on incoming merge rate.&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;CustomAnalyzer has been added that allows to configure analyzers like you do in Solr's index schema. This class has a builder API to configure Tokenizers, TokenFilters, and CharFilters based on their SPI names and parameters as documented by the corresponding factories.&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;Memory index now supports payloads.&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;Added a filter cache with a usage tracking policy that caches filters based on frequency of use.&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;The default codec has an option to control BEST_SPEED or BEST_COMPRESSION for stored fields.&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;Stored fields are merged more efficiently, especially when upgrading from previous versions or using SortingMergePolicy&lt;/p&gt;
&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;NOTE: Lucene 5 no longer supports the Lucene 3.x index format. Opening indexes will result in IndexFormatTooOldException. It is recommended to either reindex all your data, or upgrade the old indexes with the IndexUpgrader tool of latest Lucene 4 version (4.10.x). Those indexes can then be read (see next section) with Lucene 5.&lt;/p&gt;
&lt;p&gt;To read more about the changes, also see: &lt;a href="http://blog.mikemccandless.com/2014/11/apache-lucene-500-is-coming.html"&gt;http://blog.mikemccandless.com/2014/11/apache-lucene-500-is-coming.html&lt;/a&gt;&lt;/p&gt;
&lt;p&gt;Please read &lt;a href="/core/5_0_0/changes/Changes.html"&gt;CHANGES.txt&lt;/a&gt; and MIGRATE.txt for a full list of new features and notes on upgrading.&lt;/p&gt;</content><category term="core/news"></category></entry><entry><title>Lucene Core 4.10.3 Available</title><link href="/" rel="alternate"></link><published>2014-12-29T00:00:00+00:00</published><updated>2014-12-29T00:00:00+00:00</updated><author><name>Lucene Developers</name></author><id>tag:None,2014-12-29:/</id><summary type="html">&lt;p&gt;The Lucene PMC is pleased to announce the release of Apache Lucene 4.10.3&lt;/p&gt;
&lt;p&gt;Apache Lucene is a high-performance, full-featured text search engine
library written entirely in Java. It is a technology suitable for nearly
any application that requires full-text search, especially cross-platform.&lt;/p&gt;
&lt;p&gt;The release is available for immediate …&lt;/p&gt;</summary><content type="html">&lt;p&gt;The Lucene PMC is pleased to announce the release of Apache Lucene 4.10.3&lt;/p&gt;
&lt;p&gt;Apache Lucene is a high-performance, full-featured text search engine
library written entirely in Java. It is a technology suitable for nearly
any application that requires full-text search, especially cross-platform.&lt;/p&gt;
&lt;p&gt;The release is available for immediate download at:
 &lt;a href="https://lucene.apache.org/core/mirrors-core-latest-redir.html"&gt;https://lucene.apache.org/core/mirrors-core-latest-redir.html&lt;/a&gt;&lt;/p&gt;
&lt;p&gt;Lucene 4.10.3 includes 12 bug fixes.&lt;/p&gt;
&lt;p&gt;See the &lt;a href="/core/4_10_3/changes/Changes.html"&gt;CHANGES.txt&lt;/a&gt; file included with the
release for a full list of changes and further details, and Happy Holidays!&lt;/p&gt;</content><category term="core/news"></category></entry><entry><title>Lucene Core 4.10.2 Available</title><link href="/" rel="alternate"></link><published>2014-10-31T00:00:00+00:00</published><updated>2014-10-31T00:00:00+00:00</updated><author><name>Lucene Developers</name></author><id>tag:None,2014-10-31:/</id><summary type="html">&lt;p&gt;The Lucene PMC is pleased to announce the release of Apache Lucene 4.10.2&lt;/p&gt;
&lt;p&gt;Apache Lucene is a high-performance, full-featured text search engine
library written entirely in Java. It is a technology suitable for nearly
any application that requires full-text search, especially cross-platform.&lt;/p&gt;
&lt;p&gt;The release is available for immediate …&lt;/p&gt;</summary><content type="html">&lt;p&gt;The Lucene PMC is pleased to announce the release of Apache Lucene 4.10.2&lt;/p&gt;
&lt;p&gt;Apache Lucene is a high-performance, full-featured text search engine
library written entirely in Java. It is a technology suitable for nearly
any application that requires full-text search, especially cross-platform.&lt;/p&gt;
&lt;p&gt;The release is available for immediate download at:
 &lt;a href="https://lucene.apache.org/core/mirrors-core-latest-redir.html"&gt;https://lucene.apache.org/core/mirrors-core-latest-redir.html&lt;/a&gt;&lt;/p&gt;
&lt;p&gt;Lucene 4.10.2 includes 2 bug fixes.&lt;/p&gt;
&lt;p&gt;See the &lt;a href="/core/4_10_2/changes/Changes.html"&gt;CHANGES.txt&lt;/a&gt; file included with the
release for a full list of changes and further details, and Happy Halloween!&lt;/p&gt;</content><category term="core/news"></category></entry><entry><title>Lucene Core 4.10.1 Available</title><link href="/" rel="alternate"></link><published>2014-09-29T00:00:00+00:00</published><updated>2014-09-29T00:00:00+00:00</updated><author><name>Lucene Developers</name></author><id>tag:None,2014-09-29:/</id><summary type="html">&lt;p&gt;The Lucene PMC is pleased to announce the release of Apache Lucene 4.10.1&lt;/p&gt;
&lt;p&gt;Apache Lucene is a high-performance, full-featured text search engine
library written entirely in Java. It is a technology suitable for nearly
any application that requires full-text search, especially cross-platform.&lt;/p&gt;
&lt;p&gt;The release is available for immediate …&lt;/p&gt;</summary><content type="html">&lt;p&gt;The Lucene PMC is pleased to announce the release of Apache Lucene 4.10.1&lt;/p&gt;
&lt;p&gt;Apache Lucene is a high-performance, full-featured text search engine
library written entirely in Java. It is a technology suitable for nearly
any application that requires full-text search, especially cross-platform.&lt;/p&gt;
&lt;p&gt;The release is available for immediate download at:
 &lt;a href="https://lucene.apache.org/core/mirrors-core-latest-redir.html"&gt;https://lucene.apache.org/core/mirrors-core-latest-redir.html&lt;/a&gt;&lt;/p&gt;
&lt;p&gt;Lucene 4.10.1 includes 7 bug fixes.&lt;/p&gt;
&lt;p&gt;See the &lt;a href="/core/4_10_1/changes/Changes.html"&gt;CHANGES.txt&lt;/a&gt; file included with the
release for a full list of changes and further details.&lt;/p&gt;</content><category term="core/news"></category></entry><entry><title>Lucene Core 4.9.1 Available</title><link href="/" rel="alternate"></link><published>2014-09-22T00:00:00+00:00</published><updated>2014-09-22T00:00:00+00:00</updated><author><name>Lucene Developers</name></author><id>tag:None,2014-09-22:/</id><summary type="html">&lt;p&gt;The Lucene PMC is pleased to announce the release of Apache Lucene 4.9.1&lt;/p&gt;
&lt;p&gt;Apache Lucene is a high-performance, full-featured text search engine
library written entirely in Java. It is a technology suitable for nearly
any application that requires full-text search, especially cross-platform.&lt;/p&gt;
&lt;p&gt;The release is available for immediate …&lt;/p&gt;</summary><content type="html">&lt;p&gt;The Lucene PMC is pleased to announce the release of Apache Lucene 4.9.1&lt;/p&gt;
&lt;p&gt;Apache Lucene is a high-performance, full-featured text search engine
library written entirely in Java. It is a technology suitable for nearly
any application that requires full-text search, especially cross-platform.&lt;/p&gt;
&lt;p&gt;The release is available for immediate download at:
 &lt;a href="https://lucene.apache.org/core/mirrors-core-latest-redir.html"&gt;https://lucene.apache.org/core/mirrors-core-latest-redir.html&lt;/a&gt;&lt;/p&gt;
&lt;p&gt;Lucene 4.9.1 includes 7 bug fixes.&lt;/p&gt;
&lt;p&gt;See the &lt;a href="/core/4_9_1/changes/Changes.html"&gt;CHANGES.txt&lt;/a&gt; file included with the
release for a full list of changes and further details.&lt;/p&gt;</content><category term="core/news"></category></entry><entry><title>Lucene Core 4.10.0 Available</title><link href="/" rel="alternate"></link><published>2014-09-03T00:00:00+00:00</published><updated>2014-09-03T00:00:00+00:00</updated><author><name>Lucene Developers</name></author><id>tag:None,2014-09-03:/</id><summary type="html">&lt;p&gt;The Lucene PMC is pleased to announce the release of Apache Lucene 4.10.0&lt;/p&gt;
&lt;p&gt;Apache Lucene is a high-performance, full-featured text search engine
library written entirely in Java. It is a technology suitable for nearly
any application that requires full-text search, especially cross-platform.&lt;/p&gt;
&lt;p&gt;This release contains numerous bug fixes …&lt;/p&gt;</summary><content type="html">&lt;p&gt;The Lucene PMC is pleased to announce the release of Apache Lucene 4.10.0&lt;/p&gt;
&lt;p&gt;Apache Lucene is a high-performance, full-featured text search engine
library written entirely in Java. It is a technology suitable for nearly
any application that requires full-text search, especially cross-platform.&lt;/p&gt;
&lt;p&gt;This release contains numerous bug fixes, optimizations, and
improvements, some of which are highlighted below. The release
is available for immediate download at:
  &lt;a href="https://lucene.apache.org/core/mirrors-core-latest-redir.html"&gt;https://lucene.apache.org/core/mirrors-core-latest-redir.html&lt;/a&gt;&lt;/p&gt;
&lt;p&gt;See the &lt;a href="/core/4_10_0/changes/Changes.html"&gt;CHANGES.txt&lt;/a&gt; file included with the release for a full list of
details.&lt;/p&gt;
&lt;p&gt;Lucene 4.10.0 Release Highlights:&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;
&lt;p&gt;New TermAutomatonQuery using an automaton for proximity queries.
  &lt;a href="http://blog.mikemccandless.com/2014/08/a-new-proximity-query-for-lucene-using.html"&gt;http://blog.mikemccandless.com/2014/08/a-new-proximity-query-for-lucene-using.html&lt;/a&gt;&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;New OrdsBlockTree terms dictionary supporting ord lookup.&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;Simplified matchVersion handling for Analyzers with new setVersion method, as well as Analyzer constructors not requiring Version.&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;Fixed possible corruption when opening a 3.x index with NRT reader.&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;Fixed edge case in StandardTokenizer that caused extremely slow parsing times with long text which partially matched grammar rules.&lt;/p&gt;
&lt;/li&gt;
&lt;/ul&gt;</content><category term="core/news"></category></entry><entry><title>Lucene Core 4.9.0 Available</title><link href="/" rel="alternate"></link><published>2014-06-25T00:00:00+00:00</published><updated>2014-06-25T00:00:00+00:00</updated><author><name>Lucene Developers</name></author><id>tag:None,2014-06-25:/</id><summary type="html">&lt;p&gt;The Lucene PMC is pleased to announce the release of Apache Lucene 4.9.0&lt;/p&gt;
&lt;p&gt;Apache Lucene is a high-performance, full-featured text search engine
library written entirely in Java. It is a technology suitable for nearly
any application that requires full-text search, especially cross-platform.&lt;/p&gt;
&lt;p&gt;This release contains numerous bug fixes …&lt;/p&gt;</summary><content type="html">&lt;p&gt;The Lucene PMC is pleased to announce the release of Apache Lucene 4.9.0&lt;/p&gt;
&lt;p&gt;Apache Lucene is a high-performance, full-featured text search engine
library written entirely in Java. It is a technology suitable for nearly
any application that requires full-text search, especially cross-platform.&lt;/p&gt;
&lt;p&gt;This release contains numerous bug fixes, optimizations, and
improvements, some of which are highlighted below. The release
is available for immediate download at:
  &lt;a href="https://lucene.apache.org/core/mirrors-core-latest-redir.html"&gt;https://lucene.apache.org/core/mirrors-core-latest-redir.html&lt;/a&gt;&lt;/p&gt;
&lt;p&gt;See the &lt;a href="/core/4_9_0/changes/Changes.html"&gt;CHANGES.txt&lt;/a&gt; file included with the release for a full list of
details.&lt;/p&gt;
&lt;p&gt;Lucene 4.9.0 Release Highlights:&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;
&lt;p&gt;New Terms.getMin/Max methods to retrieve the lowest and highest
  terms per field.&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;New IDVersionPostingsFormat, optimized for ID lookups that associate
  a monotonically increasing version per ID.&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;Atomic update of a set of doc values fields.&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;Numerous optimizations for doc values search-time performance.&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;New (default) Lucene49NormsFormat to better compress certain cases
  such as very short fields.&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;New SORTED_NUMERIC docvalues type for efficient processing of
  multi-valued numeric fields.&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;Indexer passes previous token stream for easier reuse.&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;MoreLikeThis accepts multiple values per field.&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;All classes that estimate their RAM usage now implement a new
  Accountable interface.&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;Lucene files are now written by (File)OutputStream on all platforms,
  completely disallowing seeking with simplified IO APIs.&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;Improve the confusing error message when MMapDirectory cannot create
  a new map.&lt;/p&gt;
&lt;/li&gt;
&lt;/ul&gt;</content><category term="core/news"></category></entry><entry><title>Lucene Core 4.8.1 Available</title><link href="/" rel="alternate"></link><published>2014-05-20T00:00:00+00:00</published><updated>2014-05-20T00:00:00+00:00</updated><author><name>Lucene Developers</name></author><id>tag:None,2014-05-20:/</id><summary type="html">&lt;p&gt;The Lucene PMC is pleased to announce the release of Apache Lucene 4.8.1&lt;/p&gt;
&lt;p&gt;Apache Lucene is a high-performance, full-featured text search engine
library written entirely in Java. It is a technology suitable for nearly
any application that requires full-text search, especially cross-platform.&lt;/p&gt;
&lt;p&gt;The release is available for immediate …&lt;/p&gt;</summary><content type="html">&lt;p&gt;The Lucene PMC is pleased to announce the release of Apache Lucene 4.8.1&lt;/p&gt;
&lt;p&gt;Apache Lucene is a high-performance, full-featured text search engine
library written entirely in Java. It is a technology suitable for nearly
any application that requires full-text search, especially cross-platform.&lt;/p&gt;
&lt;p&gt;The release is available for immediate download at:
 &lt;a href="https://lucene.apache.org/core/mirrors-core-latest-redir.html"&gt;https://lucene.apache.org/core/mirrors-core-latest-redir.html&lt;/a&gt;&lt;/p&gt;
&lt;p&gt;Lucene 4.8.1 includes 15 bug fixes.&lt;/p&gt;
&lt;p&gt;See the &lt;a href="/core/4_8_1/changes/Changes.html"&gt;CHANGES.txt&lt;/a&gt; file included with the
release for a full list of changes and further details.&lt;/p&gt;</content><category term="core/news"></category></entry><entry><title>Apache Lucene 4.8.0 Available</title><link href="/" rel="alternate"></link><published>2014-04-28T00:00:00+00:00</published><updated>2014-04-28T00:00:00+00:00</updated><author><name>Lucene Developers</name></author><id>tag:None,2014-04-28:/</id><summary type="html">&lt;p&gt;The Lucene PMC is pleased to announce the release of Apache Lucene 4.8.0&lt;/p&gt;
&lt;p&gt;Apache Lucene is a high-performance, full-featured text search engine
library written entirely in Java. It is a technology suitable for nearly
any application that requires full-text search, especially cross-platform.&lt;/p&gt;
&lt;p&gt;This release contains numerous bug fixes …&lt;/p&gt;</summary><content type="html">&lt;p&gt;The Lucene PMC is pleased to announce the release of Apache Lucene 4.8.0&lt;/p&gt;
&lt;p&gt;Apache Lucene is a high-performance, full-featured text search engine
library written entirely in Java. It is a technology suitable for nearly
any application that requires full-text search, especially cross-platform.&lt;/p&gt;
&lt;p&gt;This release contains numerous bug fixes, optimizations, and
improvements, some of which are highlighted below. The release
is available for immediate download at:
  &lt;a href="https://lucene.apache.org/core/mirrors-core-latest-redir.html"&gt;https://lucene.apache.org/core/mirrors-core-latest-redir.html&lt;/a&gt;&lt;/p&gt;
&lt;p&gt;See the &lt;a href="/core/4_8_0/changes/Changes.html"&gt;CHANGES.txt&lt;/a&gt; file included
with the release for a full list of details.&lt;/p&gt;
&lt;h3 id="lucene-480-release-highlights"&gt;Lucene 4.8.0 Release Highlights:&lt;/h3&gt;
&lt;ul&gt;
&lt;li&gt;
&lt;p&gt;Apache Lucene now requires Java 7 or greater (recommended is
  Oracle Java 7 or OpenJDK 7, minimum update 55; earlier versions
  have known JVM bugs affecting Lucene).&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;Apache Lucene is fully compatible with Java 8.&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;All index files now store end-to-end checksums, which are
  now validated during merging and reading. This ensures that
  corruptions caused by any bit-flipping hardware problems or bugs
  in the JVM can be detected earlier.  For full detection be sure
  to enable all checksums during merging (it's disabled by default).&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;Lucene has a new Rescorer/QueryRescorer API to perform second-pass
  rescoring or reranking of search results using more expensive scoring
  functions after first-pass hit collection.&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;AnalyzingInfixSuggester now supports near-real-time autosuggest.&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;Simplified impact-sorted postings (using SortingMergePolicy and
  EarlyTerminatingCollector) to use Lucene's Sort class
  to express the sort order.&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;Bulk scoring and normal iterator-based scoring were separated,
  so some queries can do bulk scoring more effectively.&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;Switched to MurmurHash3 to hash terms during indexing.&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;IndexWriter now supports updating of binary doc value fields.&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;HunspellStemFilter now uses 10 to 100x less RAM. It also loads
  all known OpenOffice dictionaries without error.&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;Lucene now also fsyncs the directory metadata on commits, if the
  operating system and file system allow it (Linux, MacOSX are
  known to work).&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;Lucene now uses Java 7 file system functions under the hood,
  so index files can be deleted on Windows, even when readers are
  still open.&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;A serious bug in NativeFSLockFactory was fixed, which could
  allow multiple IndexWriters to acquire the same lock.  The
  lock file is no longer deleted from the index directory
  even when the lock is not held.&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;Various bugfixes and optimizations since the 4.7.2 release.&lt;/p&gt;
&lt;/li&gt;
&lt;/ul&gt;</content><category term="core/news"></category></entry><entry><title>Lucene Core 4.7.2 Available</title><link href="/" rel="alternate"></link><published>2014-04-15T00:00:00+00:00</published><updated>2014-04-15T00:00:00+00:00</updated><author><name>Lucene Developers</name></author><id>tag:None,2014-04-15:/</id><summary type="html">&lt;p&gt;The Lucene PMC is pleased to announce the release of Apache Lucene 4.7.2&lt;/p&gt;
&lt;p&gt;Apache Lucene is a high-performance, full-featured text search engine
library written entirely in Java. It is a technology suitable for nearly
any application that requires full-text search, especially cross-platform.&lt;/p&gt;
&lt;p&gt;The release is available for immediate …&lt;/p&gt;</summary><content type="html">&lt;p&gt;The Lucene PMC is pleased to announce the release of Apache Lucene 4.7.2&lt;/p&gt;
&lt;p&gt;Apache Lucene is a high-performance, full-featured text search engine
library written entirely in Java. It is a technology suitable for nearly
any application that requires full-text search, especially cross-platform.&lt;/p&gt;
&lt;p&gt;The release is available for immediate download at:
 &lt;a href="https://lucene.apache.org/core/mirrors-core-latest-redir.html"&gt;https://lucene.apache.org/core/mirrors-core-latest-redir.html&lt;/a&gt;&lt;/p&gt;
&lt;p&gt;Lucene 4.7.2 includes 2 bug fixes, including a possible index corruption
with near-realtime search.&lt;/p&gt;
&lt;p&gt;See the &lt;a href="/core/4_7_2/changes/Changes.html"&gt;CHANGES.txt&lt;/a&gt; file included with the
release for a full list of changes and further details.&lt;/p&gt;</content><category term="core/news"></category></entry><entry><title>Lucene Core 4.7.1 Available</title><link href="/" rel="alternate"></link><published>2014-04-02T00:00:00+00:00</published><updated>2014-04-02T00:00:00+00:00</updated><author><name>Lucene Developers</name></author><id>tag:None,2014-04-02:/</id><summary type="html">&lt;p&gt;The Lucene PMC is pleased to announce the release of Apache Lucene 4.7.1&lt;/p&gt;
&lt;p&gt;Apache Lucene is a high-performance, full-featured text search engine
library written entirely in Java. It is a technology suitable for nearly
any application that requires full-text search, especially cross-platform.&lt;/p&gt;
&lt;p&gt;The release is available for immediate …&lt;/p&gt;</summary><content type="html">&lt;p&gt;The Lucene PMC is pleased to announce the release of Apache Lucene 4.7.1&lt;/p&gt;
&lt;p&gt;Apache Lucene is a high-performance, full-featured text search engine
library written entirely in Java. It is a technology suitable for nearly
any application that requires full-text search, especially cross-platform.&lt;/p&gt;
&lt;p&gt;The release is available for immediate download at:
 &lt;a href="https://lucene.apache.org/core/mirrors-core-latest-redir.html"&gt;https://lucene.apache.org/core/mirrors-core-latest-redir.html&lt;/a&gt;&lt;/p&gt;
&lt;p&gt;Lucene 4.7.1 includes 14 bug fixes; one build improvement; and one change in
runtime behavior: AutomatonQuery.equals is no longer implemented as "accepts
same language".&lt;/p&gt;
&lt;p&gt;See the &lt;a href="/core/4_7_1/changes/Changes.html"&gt;CHANGES.txt&lt;/a&gt; file included with the
release for a full list of changes and further details.&lt;/p&gt;</content><category term="core/news"></category></entry><entry><title>Apache Lucene 4.8 will require Java 7</title><link href="/" rel="alternate"></link><published>2014-03-12T00:00:00+00:00</published><updated>2014-03-12T00:00:00+00:00</updated><author><name>Lucene Developers</name></author><id>tag:None,2014-03-12:/</id><summary type="html">&lt;p&gt;The Apache Lucene committers decided with a large majority on the vote to require &lt;strong&gt;Java 7&lt;/strong&gt; for the next minor release of Apache Lucene (version 4.8)!&lt;/p&gt;
&lt;p&gt;The next release will also contain some improvements for Java 7:&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;
&lt;p&gt;Better file handling (especially on Windows) in the directory implementations. Files can …&lt;/p&gt;&lt;/li&gt;&lt;/ul&gt;</summary><content type="html">&lt;p&gt;The Apache Lucene committers decided with a large majority on the vote to require &lt;strong&gt;Java 7&lt;/strong&gt; for the next minor release of Apache Lucene (version 4.8)!&lt;/p&gt;
&lt;p&gt;The next release will also contain some improvements for Java 7:&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;
&lt;p&gt;Better file handling (especially on Windows) in the directory implementations. Files can now be deleted on windows, although the index is still open - like it was always possible on Unix environments (delete on last close semantics).&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;Speed improvements in sorting comparators: Sorting now uses Java 7's own comparators for integer and long sorts, which are highly optimized by the Hotspot VM.&lt;/p&gt;
&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;If you want to stay up-to-date with Lucene and Solr, you should upgrade your infrastructure to Java 7.
Please be aware that you must use at least use Java 7u1.
The recommended version at the moment is Java 7u25. Later versions like 7u40, 7u45,... have a bug causing index corrumption.
Ideally use the Java 7u60 prerelease, which has fixed this bug. Once 7u60 is out, this will be the recommended version.
In addition, there is no more Oracle/BEA JRockit available for Java 7, use the official Oracle Java 7.
JRockit was never working correctly with Lucene/Solr (causing index corrumption), so this should not be an issue.
Please also review our list of JVM bugs: &lt;a href="http://wiki.apache.org/lucene-java/JavaBugs"&gt;http://wiki.apache.org/lucene-java/JavaBugs&lt;/a&gt;&lt;/p&gt;
&lt;p&gt;&lt;em&gt;EDIT (as of 15 April 2014):&lt;/em&gt; The recently released Java 7u55 fixes the above bug causing index corrumption.
This version is now the recommended version for running Apache Lucene.&lt;/p&gt;</content><category term="core/news"></category></entry><entry><title>Lucene Core 4.7 Available</title><link href="/" rel="alternate"></link><published>2014-02-26T00:00:00+00:00</published><updated>2014-02-26T00:00:00+00:00</updated><author><name>Lucene Developers</name></author><id>tag:None,2014-02-26:/</id><summary type="html">&lt;p&gt;The Lucene PMC is pleased to announce the release of Apache Lucene 4.7&lt;/p&gt;
&lt;p&gt;Apache Lucene is a high-performance, full-featured text search engine
library written entirely in Java. It is a technology suitable for nearly
any application that requires full-text search, especially cross-platform.&lt;/p&gt;
&lt;p&gt;This release contains numerous bug fixes, optimizations …&lt;/p&gt;</summary><content type="html">&lt;p&gt;The Lucene PMC is pleased to announce the release of Apache Lucene 4.7&lt;/p&gt;
&lt;p&gt;Apache Lucene is a high-performance, full-featured text search engine
library written entirely in Java. It is a technology suitable for nearly
any application that requires full-text search, especially cross-platform.&lt;/p&gt;
&lt;p&gt;This release contains numerous bug fixes, optimizations, and
improvements, some of which are highlighted below. The release
is available for immediate download at:
  &lt;a href="https://lucene.apache.org/core/mirrors-core-latest-redir.html"&gt;https://lucene.apache.org/core/mirrors-core-latest-redir.html&lt;/a&gt;&lt;/p&gt;
&lt;p&gt;See the &lt;a href="/core/4_7_0/changes/Changes.html"&gt;CHANGES.txt&lt;/a&gt; file included
with the release for a full list of details.&lt;/p&gt;
&lt;h3 id="lucene-47-release-highlights"&gt;Lucene 4.7 Release Highlights:&lt;/h3&gt;
&lt;ul&gt;
&lt;li&gt;
&lt;p&gt;When sorting by String (SortField.STRING), you can now specify whether missing values should be sorted first (the default), or last.&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;Add two memory resident dictionaries (FST terms dictionary and FSTOrd
  terms dictionary) to improve primary key lookups. The
  PostingsBaseFormat API is also changed so that term dictionaries get
  the ability to block encode term metadata, and all dictionary
  implementations can now plug in any PostingsBaseFormat.&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;NRT support for file systems that do not have delete on last close or cannot delete while referenced semantics.&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;Add LongBitSet for managing more than 2.1B bits (otherwise use FixedBitSet).&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;Speed up Lucene range faceting from O(N) per hit to O(log(N)) per hit using segment trees.&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;Add SearcherTaxonomyManager over search and taxonomy index directories
  (i.e. not only NRT).&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;Drilling down or sideways on a Lucene facet range (using
  Range.getFilter()) is now faster for costly filters (uses random
  access, not iteration); range facet counts now accept a fast-match
  filter to avoid computing the value for documents that are out of
  bounds, e.g. using a bounding box filter with distance range faceting.&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;Add Analyzer for Kurdish.&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;Add Payload support to FileDictionary (Suggest) and make it more configurable.&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;Add a new BlendedInfixSuggester, which is like AnalyzingInfixSuggester but boosts suggestions that matched tokens with lower positions.&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;Add SimpleQueryParser: parser for human-entered queries.&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;Add multitermquery (wildcards,prefix,etc) to PostingsHighlighter.&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;Upgrade to Spatial4j 0.4.1: Parses WKT (including ENVELOPE) with extension BUFFER; buffering a point results in a Circle. JTS isn't
  needed for WKT any more but remains required for Polygons. New Shapes: ShapeCollection and BufferedLineString.&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;Add spatial SerializedDVStrategy that serializes a binary
  representation of a shape into BinaryDocValues. It supports exact
  geometry relationship calculations.&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;Various bugfixes and optimizations since the 4.6.1 release.&lt;/p&gt;
&lt;/li&gt;
&lt;/ul&gt;</content><category term="core/news"></category></entry></feed>